/*
 * Generated by gdbus-codegen 2.29.90. DO NOT EDIT.
 *
 * The license of this code is the same as for the source it was derived from.
 */

#ifndef __GDBUS_TEST_CODEGEN_GENERATED_H__
#define __GDBUS_TEST_CODEGEN_GENERATED_H__

#include <gio/gio.h>

G_BEGIN_DECLS


/* ------------------------------------------------------------------------ */
/* Declarations for org.project.Bar */

#define FOO_TYPE_BAR (foo_bar_get_type ())
#define FOO_BAR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_BAR, FooBar))
#define FOO_IS_BAR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_BAR))
#define FOO_BAR_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_BAR, FooBarIface))

struct _FooBar;
typedef struct _FooBar FooBar;
typedef struct _FooBarIface FooBarIface;

struct _FooBarIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_hello_world) (
    FooBar *object,
    GDBusMethodInvocation *invocation,
    const gchar *greeting);

  gboolean (*handle_property_cancellation) (
    FooBar *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_request_multi_property_mods) (
    FooBar *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_request_signal_emission) (
    FooBar *object,
    GDBusMethodInvocation *invocation,
    gint which_one);

  gboolean (*handle_test_non_primitive_types) (
    FooBar *object,
    GDBusMethodInvocation *invocation,
    GVariant *dict_s_to_s,
    GVariant *dict_s_to_pairs,
    GVariant *a_struct,
    const gchar *const *array_of_strings,
    const gchar *const *array_of_objpaths,
    GVariant *array_of_signatures,
    const gchar *const *array_of_bytestrings);

  gboolean (*handle_test_primitive_types) (
    FooBar *object,
    GDBusMethodInvocation *invocation,
    guchar val_byte,
    gboolean val_boolean,
    gint16 val_int16,
    guint16 val_uint16,
    gint val_int32,
    guint val_uint32,
    gint64 val_int64,
    guint64 val_uint64,
    gdouble val_double,
    const gchar *val_string,
    const gchar *val_objpath,
    const gchar *val_signature,
    const gchar *val_bytestring);

  gboolean (*handle_unimplemented_method) (
    FooBar *object,
    GDBusMethodInvocation *invocation);

  const gchar *const * (*get_aay) (FooBar *object);

  GVariant * (*get_ag) (FooBar *object);

  const gchar *const * (*get_ao) (FooBar *object);

  const gchar *const * (*get_as) (FooBar *object);

  const gchar * (*get_ay) (FooBar *object);

  gboolean  (*get_b) (FooBar *object);

  gdouble  (*get_d) (FooBar *object);

  const gchar * (*get_finally_normal_name) (FooBar *object);

  const gchar * (*get_g) (FooBar *object);

  gint  (*get_i) (FooBar *object);

  gint16  (*get_n) (FooBar *object);

  const gchar * (*get_o) (FooBar *object);

  guint16  (*get_q) (FooBar *object);

  const gchar * (*get_readonly_property) (FooBar *object);

  const gchar * (*get_s) (FooBar *object);

  guint64  (*get_t) (FooBar *object);

  guint  (*get_u) (FooBar *object);

  GVariant * (*get_unset_ag) (FooBar *object);

  const gchar *const * (*get_unset_ao) (FooBar *object);

  const gchar *const * (*get_unset_as) (FooBar *object);

  const gchar * (*get_unset_ay) (FooBar *object);

  gdouble  (*get_unset_d) (FooBar *object);

  const gchar * (*get_unset_g) (FooBar *object);

  gint  (*get_unset_i) (FooBar *object);

  const gchar * (*get_unset_o) (FooBar *object);

  const gchar * (*get_unset_s) (FooBar *object);

  GVariant * (*get_unset_struct) (FooBar *object);

  const gchar * (*get_writeonly_property) (FooBar *object);

  gint64  (*get_x) (FooBar *object);

  guchar  (*get_y) (FooBar *object);

  void (*another_signal) (
    FooBar *object,
    const gchar *word);

  void (*test_signal) (
    FooBar *object,
    gint val_int32,
    const gchar *const *array_of_strings,
    const gchar *const *array_of_bytestrings,
    GVariant *dict_s_to_pairs);

};

GType foo_bar_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_bar_interface_info (void);
guint foo_bar_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_bar_complete_hello_world (
    FooBar *object,
    GDBusMethodInvocation *invocation,
    const gchar *response);

void foo_bar_complete_test_primitive_types (
    FooBar *object,
    GDBusMethodInvocation *invocation,
    guchar ret_byte,
    gboolean ret_boolean,
    gint16 ret_int16,
    guint16 ret_uint16,
    gint ret_int32,
    guint ret_uint32,
    gint64 ret_int64,
    guint64 ret_uint64,
    gdouble ret_double,
    const gchar *ret_string,
    const gchar *ret_objpath,
    const gchar *ret_signature,
    const gchar *ret_bytestring);

void foo_bar_complete_test_non_primitive_types (
    FooBar *object,
    GDBusMethodInvocation *invocation,
    const gchar *result);

void foo_bar_complete_request_signal_emission (
    FooBar *object,
    GDBusMethodInvocation *invocation);

void foo_bar_complete_request_multi_property_mods (
    FooBar *object,
    GDBusMethodInvocation *invocation);

void foo_bar_complete_unimplemented_method (
    FooBar *object,
    GDBusMethodInvocation *invocation);

void foo_bar_complete_property_cancellation (
    FooBar *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void foo_bar_emit_test_signal (
    FooBar *object,
    gint val_int32,
    const gchar *const *array_of_strings,
    const gchar *const *array_of_bytestrings,
    GVariant *dict_s_to_pairs);

void foo_bar_emit_another_signal (
    FooBar *object,
    const gchar *word);



/* D-Bus method calls: */
void foo_bar_call_hello_world (
    FooBar *proxy,
    const gchar *greeting,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_bar_call_hello_world_finish (
    FooBar *proxy,
    gchar **out_response,
    GAsyncResult *res,
    GError **error);

gboolean foo_bar_call_hello_world_sync (
    FooBar *proxy,
    const gchar *greeting,
    gchar **out_response,
    GCancellable *cancellable,
    GError **error);

void foo_bar_call_test_primitive_types (
    FooBar *proxy,
    guchar val_byte,
    gboolean val_boolean,
    gint16 val_int16,
    guint16 val_uint16,
    gint val_int32,
    guint val_uint32,
    gint64 val_int64,
    guint64 val_uint64,
    gdouble val_double,
    const gchar *val_string,
    const gchar *val_objpath,
    const gchar *val_signature,
    const gchar *val_bytestring,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_bar_call_test_primitive_types_finish (
    FooBar *proxy,
    guchar *out_ret_byte,
    gboolean *out_ret_boolean,
    gint16 *out_ret_int16,
    guint16 *out_ret_uint16,
    gint *out_ret_int32,
    guint *out_ret_uint32,
    gint64 *out_ret_int64,
    guint64 *out_ret_uint64,
    gdouble *out_ret_double,
    gchar **out_ret_string,
    gchar **out_ret_objpath,
    gchar **out_ret_signature,
    gchar **out_ret_bytestring,
    GAsyncResult *res,
    GError **error);

gboolean foo_bar_call_test_primitive_types_sync (
    FooBar *proxy,
    guchar val_byte,
    gboolean val_boolean,
    gint16 val_int16,
    guint16 val_uint16,
    gint val_int32,
    guint val_uint32,
    gint64 val_int64,
    guint64 val_uint64,
    gdouble val_double,
    const gchar *val_string,
    const gchar *val_objpath,
    const gchar *val_signature,
    const gchar *val_bytestring,
    guchar *out_ret_byte,
    gboolean *out_ret_boolean,
    gint16 *out_ret_int16,
    guint16 *out_ret_uint16,
    gint *out_ret_int32,
    guint *out_ret_uint32,
    gint64 *out_ret_int64,
    guint64 *out_ret_uint64,
    gdouble *out_ret_double,
    gchar **out_ret_string,
    gchar **out_ret_objpath,
    gchar **out_ret_signature,
    gchar **out_ret_bytestring,
    GCancellable *cancellable,
    GError **error);

void foo_bar_call_test_non_primitive_types (
    FooBar *proxy,
    GVariant *dict_s_to_s,
    GVariant *dict_s_to_pairs,
    GVariant *a_struct,
    const gchar *const *array_of_strings,
    const gchar *const *array_of_objpaths,
    GVariant *array_of_signatures,
    const gchar *const *array_of_bytestrings,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_bar_call_test_non_primitive_types_finish (
    FooBar *proxy,
    gchar **out_result,
    GAsyncResult *res,
    GError **error);

gboolean foo_bar_call_test_non_primitive_types_sync (
    FooBar *proxy,
    GVariant *dict_s_to_s,
    GVariant *dict_s_to_pairs,
    GVariant *a_struct,
    const gchar *const *array_of_strings,
    const gchar *const *array_of_objpaths,
    GVariant *array_of_signatures,
    const gchar *const *array_of_bytestrings,
    gchar **out_result,
    GCancellable *cancellable,
    GError **error);

void foo_bar_call_request_signal_emission (
    FooBar *proxy,
    gint which_one,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_bar_call_request_signal_emission_finish (
    FooBar *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_bar_call_request_signal_emission_sync (
    FooBar *proxy,
    gint which_one,
    GCancellable *cancellable,
    GError **error);

void foo_bar_call_request_multi_property_mods (
    FooBar *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_bar_call_request_multi_property_mods_finish (
    FooBar *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_bar_call_request_multi_property_mods_sync (
    FooBar *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_bar_call_unimplemented_method (
    FooBar *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_bar_call_unimplemented_method_finish (
    FooBar *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_bar_call_unimplemented_method_sync (
    FooBar *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_bar_call_property_cancellation (
    FooBar *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_bar_call_property_cancellation_finish (
    FooBar *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_bar_call_property_cancellation_sync (
    FooBar *proxy,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guchar foo_bar_get_y (FooBar *object);
void foo_bar_set_y (FooBar *object, guchar value);

gboolean foo_bar_get_b (FooBar *object);
void foo_bar_set_b (FooBar *object, gboolean value);

gint16 foo_bar_get_n (FooBar *object);
void foo_bar_set_n (FooBar *object, gint16 value);

guint16 foo_bar_get_q (FooBar *object);
void foo_bar_set_q (FooBar *object, guint16 value);

gint foo_bar_get_i (FooBar *object);
void foo_bar_set_i (FooBar *object, gint value);

guint foo_bar_get_u (FooBar *object);
void foo_bar_set_u (FooBar *object, guint value);

gint64 foo_bar_get_x (FooBar *object);
void foo_bar_set_x (FooBar *object, gint64 value);

guint64 foo_bar_get_t (FooBar *object);
void foo_bar_set_t (FooBar *object, guint64 value);

gdouble foo_bar_get_d (FooBar *object);
void foo_bar_set_d (FooBar *object, gdouble value);

const gchar *foo_bar_get_s (FooBar *object);
gchar *foo_bar_dup_s (FooBar *object);
void foo_bar_set_s (FooBar *object, const gchar *value);

const gchar *foo_bar_get_o (FooBar *object);
gchar *foo_bar_dup_o (FooBar *object);
void foo_bar_set_o (FooBar *object, const gchar *value);

const gchar *foo_bar_get_g (FooBar *object);
gchar *foo_bar_dup_g (FooBar *object);
void foo_bar_set_g (FooBar *object, const gchar *value);

const gchar *foo_bar_get_ay (FooBar *object);
gchar *foo_bar_dup_ay (FooBar *object);
void foo_bar_set_ay (FooBar *object, const gchar *value);

const gchar *const *foo_bar_get_as (FooBar *object);
gchar **foo_bar_dup_as (FooBar *object);
void foo_bar_set_as (FooBar *object, const gchar *const *value);

const gchar *const *foo_bar_get_aay (FooBar *object);
gchar **foo_bar_dup_aay (FooBar *object);
void foo_bar_set_aay (FooBar *object, const gchar *const *value);

const gchar *const *foo_bar_get_ao (FooBar *object);
gchar **foo_bar_dup_ao (FooBar *object);
void foo_bar_set_ao (FooBar *object, const gchar *const *value);

GVariant *foo_bar_get_ag (FooBar *object);
GVariant *foo_bar_dup_ag (FooBar *object);
void foo_bar_set_ag (FooBar *object, GVariant *value);

const gchar *foo_bar_get_finally_normal_name (FooBar *object);
gchar *foo_bar_dup_finally_normal_name (FooBar *object);
void foo_bar_set_finally_normal_name (FooBar *object, const gchar *value);

const gchar *foo_bar_get_readonly_property (FooBar *object);
gchar *foo_bar_dup_readonly_property (FooBar *object);
void foo_bar_set_readonly_property (FooBar *object, const gchar *value);

const gchar *foo_bar_get_writeonly_property (FooBar *object);
gchar *foo_bar_dup_writeonly_property (FooBar *object);
void foo_bar_set_writeonly_property (FooBar *object, const gchar *value);

gint foo_bar_get_unset_i (FooBar *object);
void foo_bar_set_unset_i (FooBar *object, gint value);

gdouble foo_bar_get_unset_d (FooBar *object);
void foo_bar_set_unset_d (FooBar *object, gdouble value);

const gchar *foo_bar_get_unset_s (FooBar *object);
gchar *foo_bar_dup_unset_s (FooBar *object);
void foo_bar_set_unset_s (FooBar *object, const gchar *value);

const gchar *foo_bar_get_unset_o (FooBar *object);
gchar *foo_bar_dup_unset_o (FooBar *object);
void foo_bar_set_unset_o (FooBar *object, const gchar *value);

const gchar *foo_bar_get_unset_g (FooBar *object);
gchar *foo_bar_dup_unset_g (FooBar *object);
void foo_bar_set_unset_g (FooBar *object, const gchar *value);

const gchar *foo_bar_get_unset_ay (FooBar *object);
gchar *foo_bar_dup_unset_ay (FooBar *object);
void foo_bar_set_unset_ay (FooBar *object, const gchar *value);

const gchar *const *foo_bar_get_unset_as (FooBar *object);
gchar **foo_bar_dup_unset_as (FooBar *object);
void foo_bar_set_unset_as (FooBar *object, const gchar *const *value);

const gchar *const *foo_bar_get_unset_ao (FooBar *object);
gchar **foo_bar_dup_unset_ao (FooBar *object);
void foo_bar_set_unset_ao (FooBar *object, const gchar *const *value);

GVariant *foo_bar_get_unset_ag (FooBar *object);
GVariant *foo_bar_dup_unset_ag (FooBar *object);
void foo_bar_set_unset_ag (FooBar *object, GVariant *value);

GVariant *foo_bar_get_unset_struct (FooBar *object);
GVariant *foo_bar_dup_unset_struct (FooBar *object);
void foo_bar_set_unset_struct (FooBar *object, GVariant *value);


/* ---- */

#define FOO_TYPE_BAR_PROXY (foo_bar_proxy_get_type ())
#define FOO_BAR_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_BAR_PROXY, FooBarProxy))
#define FOO_BAR_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_BAR_PROXY, FooBarProxyClass))
#define FOO_BAR_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_BAR_PROXY, FooBarProxyClass))
#define FOO_IS_BAR_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_BAR_PROXY))
#define FOO_IS_BAR_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_BAR_PROXY))

typedef struct _FooBarProxy FooBarProxy;
typedef struct _FooBarProxyClass FooBarProxyClass;
typedef struct _FooBarProxyPrivate FooBarProxyPrivate;

struct _FooBarProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooBarProxyPrivate *priv;
};

struct _FooBarProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_bar_proxy_get_type (void) G_GNUC_CONST;

void foo_bar_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooBar *foo_bar_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooBar *foo_bar_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_bar_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooBar *foo_bar_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooBar *foo_bar_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_BAR_SKELETON (foo_bar_skeleton_get_type ())
#define FOO_BAR_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_BAR_SKELETON, FooBarSkeleton))
#define FOO_BAR_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_BAR_SKELETON, FooBarSkeletonClass))
#define FOO_BAR_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_BAR_SKELETON, FooBarSkeletonClass))
#define FOO_IS_BAR_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_BAR_SKELETON))
#define FOO_IS_BAR_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_BAR_SKELETON))

typedef struct _FooBarSkeleton FooBarSkeleton;
typedef struct _FooBarSkeletonClass FooBarSkeletonClass;
typedef struct _FooBarSkeletonPrivate FooBarSkeletonPrivate;

struct _FooBarSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooBarSkeletonPrivate *priv;
};

struct _FooBarSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_bar_skeleton_get_type (void) G_GNUC_CONST;

FooBar *foo_bar_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.project.Bar.Frobnicator */

#define FOO_TYPE_BAR_FROBNICATOR (foo_bar_frobnicator_get_type ())
#define FOO_BAR_FROBNICATOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_BAR_FROBNICATOR, FooBarFrobnicator))
#define FOO_IS_BAR_FROBNICATOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_BAR_FROBNICATOR))
#define FOO_BAR_FROBNICATOR_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_BAR_FROBNICATOR, FooBarFrobnicatorIface))

struct _FooBarFrobnicator;
typedef struct _FooBarFrobnicator FooBarFrobnicator;
typedef struct _FooBarFrobnicatorIface FooBarFrobnicatorIface;

struct _FooBarFrobnicatorIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_random_method) (
    FooBarFrobnicator *object,
    GDBusMethodInvocation *invocation);

};

GType foo_bar_frobnicator_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_bar_frobnicator_interface_info (void);
guint foo_bar_frobnicator_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_bar_frobnicator_complete_random_method (
    FooBarFrobnicator *object,
    GDBusMethodInvocation *invocation);



/* D-Bus method calls: */
void foo_bar_frobnicator_call_random_method (
    FooBarFrobnicator *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_bar_frobnicator_call_random_method_finish (
    FooBarFrobnicator *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_bar_frobnicator_call_random_method_sync (
    FooBarFrobnicator *proxy,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define FOO_TYPE_BAR_FROBNICATOR_PROXY (foo_bar_frobnicator_proxy_get_type ())
#define FOO_BAR_FROBNICATOR_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_BAR_FROBNICATOR_PROXY, FooBarFrobnicatorProxy))
#define FOO_BAR_FROBNICATOR_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_BAR_FROBNICATOR_PROXY, FooBarFrobnicatorProxyClass))
#define FOO_BAR_FROBNICATOR_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_BAR_FROBNICATOR_PROXY, FooBarFrobnicatorProxyClass))
#define FOO_IS_BAR_FROBNICATOR_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_BAR_FROBNICATOR_PROXY))
#define FOO_IS_BAR_FROBNICATOR_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_BAR_FROBNICATOR_PROXY))

typedef struct _FooBarFrobnicatorProxy FooBarFrobnicatorProxy;
typedef struct _FooBarFrobnicatorProxyClass FooBarFrobnicatorProxyClass;
typedef struct _FooBarFrobnicatorProxyPrivate FooBarFrobnicatorProxyPrivate;

struct _FooBarFrobnicatorProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooBarFrobnicatorProxyPrivate *priv;
};

struct _FooBarFrobnicatorProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_bar_frobnicator_proxy_get_type (void) G_GNUC_CONST;

void foo_bar_frobnicator_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooBarFrobnicator *foo_bar_frobnicator_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooBarFrobnicator *foo_bar_frobnicator_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_bar_frobnicator_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooBarFrobnicator *foo_bar_frobnicator_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooBarFrobnicator *foo_bar_frobnicator_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_BAR_FROBNICATOR_SKELETON (foo_bar_frobnicator_skeleton_get_type ())
#define FOO_BAR_FROBNICATOR_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_BAR_FROBNICATOR_SKELETON, FooBarFrobnicatorSkeleton))
#define FOO_BAR_FROBNICATOR_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_BAR_FROBNICATOR_SKELETON, FooBarFrobnicatorSkeletonClass))
#define FOO_BAR_FROBNICATOR_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_BAR_FROBNICATOR_SKELETON, FooBarFrobnicatorSkeletonClass))
#define FOO_IS_BAR_FROBNICATOR_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_BAR_FROBNICATOR_SKELETON))
#define FOO_IS_BAR_FROBNICATOR_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_BAR_FROBNICATOR_SKELETON))

typedef struct _FooBarFrobnicatorSkeleton FooBarFrobnicatorSkeleton;
typedef struct _FooBarFrobnicatorSkeletonClass FooBarFrobnicatorSkeletonClass;
typedef struct _FooBarFrobnicatorSkeletonPrivate FooBarFrobnicatorSkeletonPrivate;

struct _FooBarFrobnicatorSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooBarFrobnicatorSkeletonPrivate *priv;
};

struct _FooBarFrobnicatorSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_bar_frobnicator_skeleton_get_type (void) G_GNUC_CONST;

FooBarFrobnicator *foo_bar_frobnicator_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.project.Baz */

#define FOO_TYPE_BAZ (foo_baz_get_type ())
#define FOO_BAZ(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_BAZ, FooBaz))
#define FOO_IS_BAZ(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_BAZ))
#define FOO_BAZ_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_BAZ, FooBazIface))

struct _FooBaz;
typedef struct _FooBaz FooBaz;
typedef struct _FooBazIface FooBazIface;

struct _FooBazIface
{
  GTypeInterface parent_iface;
};

GType foo_baz_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_baz_interface_info (void);
guint foo_baz_override_properties (GObjectClass *klass, guint property_id_begin);


/* ---- */

#define FOO_TYPE_BAZ_PROXY (foo_baz_proxy_get_type ())
#define FOO_BAZ_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_BAZ_PROXY, FooBazProxy))
#define FOO_BAZ_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_BAZ_PROXY, FooBazProxyClass))
#define FOO_BAZ_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_BAZ_PROXY, FooBazProxyClass))
#define FOO_IS_BAZ_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_BAZ_PROXY))
#define FOO_IS_BAZ_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_BAZ_PROXY))

typedef struct _FooBazProxy FooBazProxy;
typedef struct _FooBazProxyClass FooBazProxyClass;
typedef struct _FooBazProxyPrivate FooBazProxyPrivate;

struct _FooBazProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooBazProxyPrivate *priv;
};

struct _FooBazProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_baz_proxy_get_type (void) G_GNUC_CONST;

void foo_baz_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooBaz *foo_baz_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooBaz *foo_baz_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_baz_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooBaz *foo_baz_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooBaz *foo_baz_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_BAZ_SKELETON (foo_baz_skeleton_get_type ())
#define FOO_BAZ_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_BAZ_SKELETON, FooBazSkeleton))
#define FOO_BAZ_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_BAZ_SKELETON, FooBazSkeletonClass))
#define FOO_BAZ_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_BAZ_SKELETON, FooBazSkeletonClass))
#define FOO_IS_BAZ_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_BAZ_SKELETON))
#define FOO_IS_BAZ_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_BAZ_SKELETON))

typedef struct _FooBazSkeleton FooBazSkeleton;
typedef struct _FooBazSkeletonClass FooBazSkeletonClass;
typedef struct _FooBazSkeletonPrivate FooBazSkeletonPrivate;

struct _FooBazSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooBazSkeletonPrivate *priv;
};

struct _FooBazSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_baz_skeleton_get_type (void) G_GNUC_CONST;

FooBaz *foo_baz_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for com.acme.Coyote */

#define FOO_TYPE_COM_ACME_COYOTE (foo_com_acme_coyote_get_type ())
#define FOO_COM_ACME_COYOTE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_COM_ACME_COYOTE, FooComAcmeCoyote))
#define FOO_IS_COM_ACME_COYOTE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_COM_ACME_COYOTE))
#define FOO_COM_ACME_COYOTE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_COM_ACME_COYOTE, FooComAcmeCoyoteIface))

struct _FooComAcmeCoyote;
typedef struct _FooComAcmeCoyote FooComAcmeCoyote;
typedef struct _FooComAcmeCoyoteIface FooComAcmeCoyoteIface;

struct _FooComAcmeCoyoteIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_attack) (
    FooComAcmeCoyote *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_run) (
    FooComAcmeCoyote *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_sleep) (
    FooComAcmeCoyote *object,
    GDBusMethodInvocation *invocation);

  const gchar * (*get_mood) (FooComAcmeCoyote *object);

  void (*surprised) (
    FooComAcmeCoyote *object);

};

GType foo_com_acme_coyote_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_com_acme_coyote_interface_info (void);
guint foo_com_acme_coyote_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_com_acme_coyote_complete_run (
    FooComAcmeCoyote *object,
    GDBusMethodInvocation *invocation);

void foo_com_acme_coyote_complete_sleep (
    FooComAcmeCoyote *object,
    GDBusMethodInvocation *invocation);

void foo_com_acme_coyote_complete_attack (
    FooComAcmeCoyote *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void foo_com_acme_coyote_emit_surprised (
    FooComAcmeCoyote *object);



/* D-Bus method calls: */
void foo_com_acme_coyote_call_run (
    FooComAcmeCoyote *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_com_acme_coyote_call_run_finish (
    FooComAcmeCoyote *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_com_acme_coyote_call_run_sync (
    FooComAcmeCoyote *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_com_acme_coyote_call_sleep (
    FooComAcmeCoyote *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_com_acme_coyote_call_sleep_finish (
    FooComAcmeCoyote *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_com_acme_coyote_call_sleep_sync (
    FooComAcmeCoyote *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_com_acme_coyote_call_attack (
    FooComAcmeCoyote *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_com_acme_coyote_call_attack_finish (
    FooComAcmeCoyote *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_com_acme_coyote_call_attack_sync (
    FooComAcmeCoyote *proxy,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
const gchar *foo_com_acme_coyote_get_mood (FooComAcmeCoyote *object);
gchar *foo_com_acme_coyote_dup_mood (FooComAcmeCoyote *object);
void foo_com_acme_coyote_set_mood (FooComAcmeCoyote *object, const gchar *value);


/* ---- */

#define FOO_TYPE_COM_ACME_COYOTE_PROXY (foo_com_acme_coyote_proxy_get_type ())
#define FOO_COM_ACME_COYOTE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_COM_ACME_COYOTE_PROXY, FooComAcmeCoyoteProxy))
#define FOO_COM_ACME_COYOTE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_COM_ACME_COYOTE_PROXY, FooComAcmeCoyoteProxyClass))
#define FOO_COM_ACME_COYOTE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_COM_ACME_COYOTE_PROXY, FooComAcmeCoyoteProxyClass))
#define FOO_IS_COM_ACME_COYOTE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_COM_ACME_COYOTE_PROXY))
#define FOO_IS_COM_ACME_COYOTE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_COM_ACME_COYOTE_PROXY))

typedef struct _FooComAcmeCoyoteProxy FooComAcmeCoyoteProxy;
typedef struct _FooComAcmeCoyoteProxyClass FooComAcmeCoyoteProxyClass;
typedef struct _FooComAcmeCoyoteProxyPrivate FooComAcmeCoyoteProxyPrivate;

struct _FooComAcmeCoyoteProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooComAcmeCoyoteProxyPrivate *priv;
};

struct _FooComAcmeCoyoteProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_com_acme_coyote_proxy_get_type (void) G_GNUC_CONST;

void foo_com_acme_coyote_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooComAcmeCoyote *foo_com_acme_coyote_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooComAcmeCoyote *foo_com_acme_coyote_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_com_acme_coyote_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooComAcmeCoyote *foo_com_acme_coyote_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooComAcmeCoyote *foo_com_acme_coyote_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_COM_ACME_COYOTE_SKELETON (foo_com_acme_coyote_skeleton_get_type ())
#define FOO_COM_ACME_COYOTE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_COM_ACME_COYOTE_SKELETON, FooComAcmeCoyoteSkeleton))
#define FOO_COM_ACME_COYOTE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_COM_ACME_COYOTE_SKELETON, FooComAcmeCoyoteSkeletonClass))
#define FOO_COM_ACME_COYOTE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_COM_ACME_COYOTE_SKELETON, FooComAcmeCoyoteSkeletonClass))
#define FOO_IS_COM_ACME_COYOTE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_COM_ACME_COYOTE_SKELETON))
#define FOO_IS_COM_ACME_COYOTE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_COM_ACME_COYOTE_SKELETON))

typedef struct _FooComAcmeCoyoteSkeleton FooComAcmeCoyoteSkeleton;
typedef struct _FooComAcmeCoyoteSkeletonClass FooComAcmeCoyoteSkeletonClass;
typedef struct _FooComAcmeCoyoteSkeletonPrivate FooComAcmeCoyoteSkeletonPrivate;

struct _FooComAcmeCoyoteSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooComAcmeCoyoteSkeletonPrivate *priv;
};

struct _FooComAcmeCoyoteSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_com_acme_coyote_skeleton_get_type (void) G_GNUC_CONST;

FooComAcmeCoyote *foo_com_acme_coyote_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for com.acme.Rocket */

#define FOO_TYPE_ROCKET123 (foo_rocket123_get_type ())
#define FOO_ROCKET123(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_ROCKET123, FooRocket123))
#define FOO_IS_ROCKET123(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_ROCKET123))
#define FOO_ROCKET123_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_ROCKET123, FooRocket123Iface))

struct _FooRocket123;
typedef struct _FooRocket123 FooRocket123;
typedef struct _FooRocket123Iface FooRocket123Iface;

struct _FooRocket123Iface
{
  GTypeInterface parent_iface;



  gboolean (*handle_ignite_xyz) (
    FooRocket123 *object,
    GDBusMethodInvocation *invocation);

  GVariant * (*get_direction) (FooRocket123 *object);

  gdouble  (*get_speed_xyz) (FooRocket123 *object);

  const gchar * (*get_type_) (FooRocket123 *object);

  void (*exploded_xyz) (
    FooRocket123 *object);

};

GType foo_rocket123_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_rocket123_interface_info (void);
guint foo_rocket123_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_rocket123_complete_ignite_xyz (
    FooRocket123 *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void foo_rocket123_emit_exploded_xyz (
    FooRocket123 *object);



/* D-Bus method calls: */
void foo_rocket123_call_ignite_xyz (
    FooRocket123 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_rocket123_call_ignite_xyz_finish (
    FooRocket123 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_rocket123_call_ignite_xyz_sync (
    FooRocket123 *proxy,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
gdouble foo_rocket123_get_speed_xyz (FooRocket123 *object);
void foo_rocket123_set_speed_xyz (FooRocket123 *object, gdouble value);

GVariant *foo_rocket123_get_direction (FooRocket123 *object);
GVariant *foo_rocket123_dup_direction (FooRocket123 *object);
void foo_rocket123_set_direction (FooRocket123 *object, GVariant *value);

const gchar *foo_rocket123_get_type_ (FooRocket123 *object);
gchar *foo_rocket123_dup_type_ (FooRocket123 *object);
void foo_rocket123_set_type_ (FooRocket123 *object, const gchar *value);


/* ---- */

#define FOO_TYPE_ROCKET123_PROXY (foo_rocket123_proxy_get_type ())
#define FOO_ROCKET123_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_ROCKET123_PROXY, FooRocket123Proxy))
#define FOO_ROCKET123_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_ROCKET123_PROXY, FooRocket123ProxyClass))
#define FOO_ROCKET123_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_ROCKET123_PROXY, FooRocket123ProxyClass))
#define FOO_IS_ROCKET123_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_ROCKET123_PROXY))
#define FOO_IS_ROCKET123_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_ROCKET123_PROXY))

typedef struct _FooRocket123Proxy FooRocket123Proxy;
typedef struct _FooRocket123ProxyClass FooRocket123ProxyClass;
typedef struct _FooRocket123ProxyPrivate FooRocket123ProxyPrivate;

struct _FooRocket123Proxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooRocket123ProxyPrivate *priv;
};

struct _FooRocket123ProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_rocket123_proxy_get_type (void) G_GNUC_CONST;

void foo_rocket123_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooRocket123 *foo_rocket123_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooRocket123 *foo_rocket123_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_rocket123_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooRocket123 *foo_rocket123_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooRocket123 *foo_rocket123_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_ROCKET123_SKELETON (foo_rocket123_skeleton_get_type ())
#define FOO_ROCKET123_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_ROCKET123_SKELETON, FooRocket123Skeleton))
#define FOO_ROCKET123_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_ROCKET123_SKELETON, FooRocket123SkeletonClass))
#define FOO_ROCKET123_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_ROCKET123_SKELETON, FooRocket123SkeletonClass))
#define FOO_IS_ROCKET123_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_ROCKET123_SKELETON))
#define FOO_IS_ROCKET123_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_ROCKET123_SKELETON))

typedef struct _FooRocket123Skeleton FooRocket123Skeleton;
typedef struct _FooRocket123SkeletonClass FooRocket123SkeletonClass;
typedef struct _FooRocket123SkeletonPrivate FooRocket123SkeletonPrivate;

struct _FooRocket123Skeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooRocket123SkeletonPrivate *priv;
};

struct _FooRocket123SkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_rocket123_skeleton_get_type (void) G_GNUC_CONST;

FooRocket123 *foo_rocket123_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.project.Bat */

#define FOO_TYPE_BAT (foo_bat_get_type ())
#define FOO_BAT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_BAT, FooBat))
#define FOO_IS_BAT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_BAT))
#define FOO_BAT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_BAT, FooBatIface))

struct _FooBat;
typedef struct _FooBat FooBat;
typedef struct _FooBatIface FooBatIface;

struct _FooBatIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_force_method) (
    FooBat *object,
    GDBusMethodInvocation *invocation,
    GVariant *force_in_i,
    GVariant *force_in_s,
    GVariant *force_in_ay,
    GVariant *force_in_struct);

  GVariant * (*get_force_ay) (FooBat *object);

  GVariant * (*get_force_i) (FooBat *object);

  GVariant * (*get_force_s) (FooBat *object);

  GVariant * (*get_force_struct) (FooBat *object);

  void (*force_signal) (
    FooBat *object,
    GVariant *force_i,
    GVariant *force_s,
    GVariant *force_ay,
    GVariant *force_struct);

};

GType foo_bat_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_bat_interface_info (void);
guint foo_bat_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_bat_complete_force_method (
    FooBat *object,
    GDBusMethodInvocation *invocation,
    GVariant *force_out_i,
    GVariant *force_out_s,
    GVariant *force_out_ay,
    GVariant *force_out_struct);



/* D-Bus signal emissions functions: */
void foo_bat_emit_force_signal (
    FooBat *object,
    GVariant *force_i,
    GVariant *force_s,
    GVariant *force_ay,
    GVariant *force_struct);



/* D-Bus method calls: */
void foo_bat_call_force_method (
    FooBat *proxy,
    GVariant *force_in_i,
    GVariant *force_in_s,
    GVariant *force_in_ay,
    GVariant *force_in_struct,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_bat_call_force_method_finish (
    FooBat *proxy,
    GVariant **out_force_out_i,
    GVariant **out_force_out_s,
    GVariant **out_force_out_ay,
    GVariant **out_force_out_struct,
    GAsyncResult *res,
    GError **error);

gboolean foo_bat_call_force_method_sync (
    FooBat *proxy,
    GVariant *force_in_i,
    GVariant *force_in_s,
    GVariant *force_in_ay,
    GVariant *force_in_struct,
    GVariant **out_force_out_i,
    GVariant **out_force_out_s,
    GVariant **out_force_out_ay,
    GVariant **out_force_out_struct,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
GVariant *foo_bat_get_force_i (FooBat *object);
GVariant *foo_bat_dup_force_i (FooBat *object);
void foo_bat_set_force_i (FooBat *object, GVariant *value);

GVariant *foo_bat_get_force_s (FooBat *object);
GVariant *foo_bat_dup_force_s (FooBat *object);
void foo_bat_set_force_s (FooBat *object, GVariant *value);

GVariant *foo_bat_get_force_ay (FooBat *object);
GVariant *foo_bat_dup_force_ay (FooBat *object);
void foo_bat_set_force_ay (FooBat *object, GVariant *value);

GVariant *foo_bat_get_force_struct (FooBat *object);
GVariant *foo_bat_dup_force_struct (FooBat *object);
void foo_bat_set_force_struct (FooBat *object, GVariant *value);


/* ---- */

#define FOO_TYPE_BAT_PROXY (foo_bat_proxy_get_type ())
#define FOO_BAT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_BAT_PROXY, FooBatProxy))
#define FOO_BAT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_BAT_PROXY, FooBatProxyClass))
#define FOO_BAT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_BAT_PROXY, FooBatProxyClass))
#define FOO_IS_BAT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_BAT_PROXY))
#define FOO_IS_BAT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_BAT_PROXY))

typedef struct _FooBatProxy FooBatProxy;
typedef struct _FooBatProxyClass FooBatProxyClass;
typedef struct _FooBatProxyPrivate FooBatProxyPrivate;

struct _FooBatProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooBatProxyPrivate *priv;
};

struct _FooBatProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_bat_proxy_get_type (void) G_GNUC_CONST;

void foo_bat_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooBat *foo_bat_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooBat *foo_bat_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_bat_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooBat *foo_bat_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooBat *foo_bat_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_BAT_SKELETON (foo_bat_skeleton_get_type ())
#define FOO_BAT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_BAT_SKELETON, FooBatSkeleton))
#define FOO_BAT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_BAT_SKELETON, FooBatSkeletonClass))
#define FOO_BAT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_BAT_SKELETON, FooBatSkeletonClass))
#define FOO_IS_BAT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_BAT_SKELETON))
#define FOO_IS_BAT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_BAT_SKELETON))

typedef struct _FooBatSkeleton FooBatSkeleton;
typedef struct _FooBatSkeletonClass FooBatSkeletonClass;
typedef struct _FooBatSkeletonPrivate FooBatSkeletonPrivate;

struct _FooBatSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooBatSkeletonPrivate *priv;
};

struct _FooBatSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_bat_skeleton_get_type (void) G_GNUC_CONST;

FooBat *foo_bat_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.project.Authorize */

#define FOO_TYPE_AUTHORIZE (foo_authorize_get_type ())
#define FOO_AUTHORIZE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_AUTHORIZE, FooAuthorize))
#define FOO_IS_AUTHORIZE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_AUTHORIZE))
#define FOO_AUTHORIZE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_AUTHORIZE, FooAuthorizeIface))

struct _FooAuthorize;
typedef struct _FooAuthorize FooAuthorize;
typedef struct _FooAuthorizeIface FooAuthorizeIface;

struct _FooAuthorizeIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_check_authorized) (
    FooAuthorize *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_check_not_authorized) (
    FooAuthorize *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_check_not_authorized_from_object) (
    FooAuthorize *object,
    GDBusMethodInvocation *invocation);

};

GType foo_authorize_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_authorize_interface_info (void);
guint foo_authorize_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_authorize_complete_check_not_authorized (
    FooAuthorize *object,
    GDBusMethodInvocation *invocation);

void foo_authorize_complete_check_authorized (
    FooAuthorize *object,
    GDBusMethodInvocation *invocation);

void foo_authorize_complete_check_not_authorized_from_object (
    FooAuthorize *object,
    GDBusMethodInvocation *invocation);



/* D-Bus method calls: */
void foo_authorize_call_check_not_authorized (
    FooAuthorize *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_authorize_call_check_not_authorized_finish (
    FooAuthorize *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_authorize_call_check_not_authorized_sync (
    FooAuthorize *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_authorize_call_check_authorized (
    FooAuthorize *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_authorize_call_check_authorized_finish (
    FooAuthorize *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_authorize_call_check_authorized_sync (
    FooAuthorize *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_authorize_call_check_not_authorized_from_object (
    FooAuthorize *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_authorize_call_check_not_authorized_from_object_finish (
    FooAuthorize *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_authorize_call_check_not_authorized_from_object_sync (
    FooAuthorize *proxy,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define FOO_TYPE_AUTHORIZE_PROXY (foo_authorize_proxy_get_type ())
#define FOO_AUTHORIZE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_AUTHORIZE_PROXY, FooAuthorizeProxy))
#define FOO_AUTHORIZE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_AUTHORIZE_PROXY, FooAuthorizeProxyClass))
#define FOO_AUTHORIZE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_AUTHORIZE_PROXY, FooAuthorizeProxyClass))
#define FOO_IS_AUTHORIZE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_AUTHORIZE_PROXY))
#define FOO_IS_AUTHORIZE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_AUTHORIZE_PROXY))

typedef struct _FooAuthorizeProxy FooAuthorizeProxy;
typedef struct _FooAuthorizeProxyClass FooAuthorizeProxyClass;
typedef struct _FooAuthorizeProxyPrivate FooAuthorizeProxyPrivate;

struct _FooAuthorizeProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooAuthorizeProxyPrivate *priv;
};

struct _FooAuthorizeProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_authorize_proxy_get_type (void) G_GNUC_CONST;

void foo_authorize_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooAuthorize *foo_authorize_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooAuthorize *foo_authorize_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_authorize_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooAuthorize *foo_authorize_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooAuthorize *foo_authorize_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_AUTHORIZE_SKELETON (foo_authorize_skeleton_get_type ())
#define FOO_AUTHORIZE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_AUTHORIZE_SKELETON, FooAuthorizeSkeleton))
#define FOO_AUTHORIZE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_AUTHORIZE_SKELETON, FooAuthorizeSkeletonClass))
#define FOO_AUTHORIZE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_AUTHORIZE_SKELETON, FooAuthorizeSkeletonClass))
#define FOO_IS_AUTHORIZE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_AUTHORIZE_SKELETON))
#define FOO_IS_AUTHORIZE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_AUTHORIZE_SKELETON))

typedef struct _FooAuthorizeSkeleton FooAuthorizeSkeleton;
typedef struct _FooAuthorizeSkeletonClass FooAuthorizeSkeletonClass;
typedef struct _FooAuthorizeSkeletonPrivate FooAuthorizeSkeletonPrivate;

struct _FooAuthorizeSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooAuthorizeSkeletonPrivate *priv;
};

struct _FooAuthorizeSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_authorize_skeleton_get_type (void) G_GNUC_CONST;

FooAuthorize *foo_authorize_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.project.MethodThreads */

#define FOO_TYPE_METHOD_THREADS (foo_method_threads_get_type ())
#define FOO_METHOD_THREADS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_METHOD_THREADS, FooMethodThreads))
#define FOO_IS_METHOD_THREADS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_METHOD_THREADS))
#define FOO_METHOD_THREADS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_METHOD_THREADS, FooMethodThreadsIface))

struct _FooMethodThreads;
typedef struct _FooMethodThreads FooMethodThreads;
typedef struct _FooMethodThreadsIface FooMethodThreadsIface;

struct _FooMethodThreadsIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_get_self) (
    FooMethodThreads *object,
    GDBusMethodInvocation *invocation);

};

GType foo_method_threads_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_method_threads_interface_info (void);
guint foo_method_threads_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_method_threads_complete_get_self (
    FooMethodThreads *object,
    GDBusMethodInvocation *invocation,
    const gchar *self_pointer);



/* D-Bus method calls: */
void foo_method_threads_call_get_self (
    FooMethodThreads *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_method_threads_call_get_self_finish (
    FooMethodThreads *proxy,
    gchar **out_self_pointer,
    GAsyncResult *res,
    GError **error);

gboolean foo_method_threads_call_get_self_sync (
    FooMethodThreads *proxy,
    gchar **out_self_pointer,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define FOO_TYPE_METHOD_THREADS_PROXY (foo_method_threads_proxy_get_type ())
#define FOO_METHOD_THREADS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_METHOD_THREADS_PROXY, FooMethodThreadsProxy))
#define FOO_METHOD_THREADS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_METHOD_THREADS_PROXY, FooMethodThreadsProxyClass))
#define FOO_METHOD_THREADS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_METHOD_THREADS_PROXY, FooMethodThreadsProxyClass))
#define FOO_IS_METHOD_THREADS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_METHOD_THREADS_PROXY))
#define FOO_IS_METHOD_THREADS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_METHOD_THREADS_PROXY))

typedef struct _FooMethodThreadsProxy FooMethodThreadsProxy;
typedef struct _FooMethodThreadsProxyClass FooMethodThreadsProxyClass;
typedef struct _FooMethodThreadsProxyPrivate FooMethodThreadsProxyPrivate;

struct _FooMethodThreadsProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooMethodThreadsProxyPrivate *priv;
};

struct _FooMethodThreadsProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_method_threads_proxy_get_type (void) G_GNUC_CONST;

void foo_method_threads_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooMethodThreads *foo_method_threads_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooMethodThreads *foo_method_threads_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_method_threads_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooMethodThreads *foo_method_threads_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooMethodThreads *foo_method_threads_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_METHOD_THREADS_SKELETON (foo_method_threads_skeleton_get_type ())
#define FOO_METHOD_THREADS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_METHOD_THREADS_SKELETON, FooMethodThreadsSkeleton))
#define FOO_METHOD_THREADS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_METHOD_THREADS_SKELETON, FooMethodThreadsSkeletonClass))
#define FOO_METHOD_THREADS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_METHOD_THREADS_SKELETON, FooMethodThreadsSkeletonClass))
#define FOO_IS_METHOD_THREADS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_METHOD_THREADS_SKELETON))
#define FOO_IS_METHOD_THREADS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_METHOD_THREADS_SKELETON))

typedef struct _FooMethodThreadsSkeleton FooMethodThreadsSkeleton;
typedef struct _FooMethodThreadsSkeletonClass FooMethodThreadsSkeletonClass;
typedef struct _FooMethodThreadsSkeletonPrivate FooMethodThreadsSkeletonPrivate;

struct _FooMethodThreadsSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooMethodThreadsSkeletonPrivate *priv;
};

struct _FooMethodThreadsSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_method_threads_skeleton_get_type (void) G_GNUC_CONST;

FooMethodThreads *foo_method_threads_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.project.InlineDocs */

#define FOO_TYPE_INLINE_DOCS (foo_inline_docs_get_type ())
#define FOO_INLINE_DOCS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_INLINE_DOCS, FooInlineDocs))
#define FOO_IS_INLINE_DOCS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_INLINE_DOCS))
#define FOO_INLINE_DOCS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_INLINE_DOCS, FooInlineDocsIface))

struct _FooInlineDocs;
typedef struct _FooInlineDocs FooInlineDocs;
typedef struct _FooInlineDocsIface FooInlineDocsIface;

struct _FooInlineDocsIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_foo_method) (
    FooInlineDocs *object,
    GDBusMethodInvocation *invocation,
    const gchar *greeting);

  gboolean (*handle_method2) (
    FooInlineDocs *object,
    GDBusMethodInvocation *invocation,
    const gchar *greeting);

  const gchar * (*get_baz_property) (FooInlineDocs *object);

  const gchar * (*get_fancy_property) (FooInlineDocs *object);

  const gchar * (*get_property2) (FooInlineDocs *object);

  const gchar * (*get_property3) (FooInlineDocs *object);

  const gchar * (*get_property4) (FooInlineDocs *object);

  const gchar * (*get_property5) (FooInlineDocs *object);

  void (*bar_signal) (
    FooInlineDocs *object,
    const gchar *blah,
    const gchar *boo);

};

GType foo_inline_docs_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_inline_docs_interface_info (void);
guint foo_inline_docs_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_inline_docs_complete_foo_method (
    FooInlineDocs *object,
    GDBusMethodInvocation *invocation,
    const gchar *response);

void foo_inline_docs_complete_method2 (
    FooInlineDocs *object,
    GDBusMethodInvocation *invocation,
    const gchar *response);



/* D-Bus signal emissions functions: */
void foo_inline_docs_emit_bar_signal (
    FooInlineDocs *object,
    const gchar *blah,
    const gchar *boo);



/* D-Bus method calls: */
void foo_inline_docs_call_foo_method (
    FooInlineDocs *proxy,
    const gchar *greeting,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_inline_docs_call_foo_method_finish (
    FooInlineDocs *proxy,
    gchar **out_response,
    GAsyncResult *res,
    GError **error);

gboolean foo_inline_docs_call_foo_method_sync (
    FooInlineDocs *proxy,
    const gchar *greeting,
    gchar **out_response,
    GCancellable *cancellable,
    GError **error);

void foo_inline_docs_call_method2 (
    FooInlineDocs *proxy,
    const gchar *greeting,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_inline_docs_call_method2_finish (
    FooInlineDocs *proxy,
    gchar **out_response,
    GAsyncResult *res,
    GError **error);

gboolean foo_inline_docs_call_method2_sync (
    FooInlineDocs *proxy,
    const gchar *greeting,
    gchar **out_response,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
const gchar *foo_inline_docs_get_baz_property (FooInlineDocs *object);
gchar *foo_inline_docs_dup_baz_property (FooInlineDocs *object);
void foo_inline_docs_set_baz_property (FooInlineDocs *object, const gchar *value);

const gchar *foo_inline_docs_get_property2 (FooInlineDocs *object);
gchar *foo_inline_docs_dup_property2 (FooInlineDocs *object);
void foo_inline_docs_set_property2 (FooInlineDocs *object, const gchar *value);

const gchar *foo_inline_docs_get_property3 (FooInlineDocs *object);
gchar *foo_inline_docs_dup_property3 (FooInlineDocs *object);
void foo_inline_docs_set_property3 (FooInlineDocs *object, const gchar *value);

const gchar *foo_inline_docs_get_property4 (FooInlineDocs *object);
gchar *foo_inline_docs_dup_property4 (FooInlineDocs *object);
void foo_inline_docs_set_property4 (FooInlineDocs *object, const gchar *value);

const gchar *foo_inline_docs_get_property5 (FooInlineDocs *object);
gchar *foo_inline_docs_dup_property5 (FooInlineDocs *object);
void foo_inline_docs_set_property5 (FooInlineDocs *object, const gchar *value);

const gchar *foo_inline_docs_get_fancy_property (FooInlineDocs *object);
gchar *foo_inline_docs_dup_fancy_property (FooInlineDocs *object);
void foo_inline_docs_set_fancy_property (FooInlineDocs *object, const gchar *value);


/* ---- */

#define FOO_TYPE_INLINE_DOCS_PROXY (foo_inline_docs_proxy_get_type ())
#define FOO_INLINE_DOCS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_INLINE_DOCS_PROXY, FooInlineDocsProxy))
#define FOO_INLINE_DOCS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_INLINE_DOCS_PROXY, FooInlineDocsProxyClass))
#define FOO_INLINE_DOCS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_INLINE_DOCS_PROXY, FooInlineDocsProxyClass))
#define FOO_IS_INLINE_DOCS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_INLINE_DOCS_PROXY))
#define FOO_IS_INLINE_DOCS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_INLINE_DOCS_PROXY))

typedef struct _FooInlineDocsProxy FooInlineDocsProxy;
typedef struct _FooInlineDocsProxyClass FooInlineDocsProxyClass;
typedef struct _FooInlineDocsProxyPrivate FooInlineDocsProxyPrivate;

struct _FooInlineDocsProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooInlineDocsProxyPrivate *priv;
};

struct _FooInlineDocsProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_inline_docs_proxy_get_type (void) G_GNUC_CONST;

void foo_inline_docs_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooInlineDocs *foo_inline_docs_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooInlineDocs *foo_inline_docs_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_inline_docs_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooInlineDocs *foo_inline_docs_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooInlineDocs *foo_inline_docs_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_INLINE_DOCS_SKELETON (foo_inline_docs_skeleton_get_type ())
#define FOO_INLINE_DOCS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_INLINE_DOCS_SKELETON, FooInlineDocsSkeleton))
#define FOO_INLINE_DOCS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_INLINE_DOCS_SKELETON, FooInlineDocsSkeletonClass))
#define FOO_INLINE_DOCS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_INLINE_DOCS_SKELETON, FooInlineDocsSkeletonClass))
#define FOO_IS_INLINE_DOCS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_INLINE_DOCS_SKELETON))
#define FOO_IS_INLINE_DOCS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_INLINE_DOCS_SKELETON))

typedef struct _FooInlineDocsSkeleton FooInlineDocsSkeleton;
typedef struct _FooInlineDocsSkeletonClass FooInlineDocsSkeletonClass;
typedef struct _FooInlineDocsSkeletonPrivate FooInlineDocsSkeletonPrivate;

struct _FooInlineDocsSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooInlineDocsSkeletonPrivate *priv;
};

struct _FooInlineDocsSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_inline_docs_skeleton_get_type (void) G_GNUC_CONST;

FooInlineDocs *foo_inline_docs_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for ChangingInterfaceV1 */

#define FOO_TYPE_CHANGING_INTERFACE_V1 (foo_changing_interface_v1_get_type ())
#define FOO_CHANGING_INTERFACE_V1(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_CHANGING_INTERFACE_V1, FooChangingInterfaceV1))
#define FOO_IS_CHANGING_INTERFACE_V1(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_CHANGING_INTERFACE_V1))
#define FOO_CHANGING_INTERFACE_V1_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_CHANGING_INTERFACE_V1, FooChangingInterfaceV1Iface))

struct _FooChangingInterfaceV1;
typedef struct _FooChangingInterfaceV1 FooChangingInterfaceV1;
typedef struct _FooChangingInterfaceV1Iface FooChangingInterfaceV1Iface;

struct _FooChangingInterfaceV1Iface
{
  GTypeInterface parent_iface;


  gboolean (*handle_bar_method) (
    FooChangingInterfaceV1 *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_baz_method) (
    FooChangingInterfaceV1 *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_foo_method) (
    FooChangingInterfaceV1 *object,
    GDBusMethodInvocation *invocation);

  void (*bar_signal) (
    FooChangingInterfaceV1 *object);

  void (*baz_signal) (
    FooChangingInterfaceV1 *object);

  void (*foo_signal) (
    FooChangingInterfaceV1 *object);

};

GType foo_changing_interface_v1_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_changing_interface_v1_interface_info (void);
guint foo_changing_interface_v1_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_changing_interface_v1_complete_foo_method (
    FooChangingInterfaceV1 *object,
    GDBusMethodInvocation *invocation);

void foo_changing_interface_v1_complete_bar_method (
    FooChangingInterfaceV1 *object,
    GDBusMethodInvocation *invocation);

void foo_changing_interface_v1_complete_baz_method (
    FooChangingInterfaceV1 *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void foo_changing_interface_v1_emit_foo_signal (
    FooChangingInterfaceV1 *object);

void foo_changing_interface_v1_emit_bar_signal (
    FooChangingInterfaceV1 *object);

void foo_changing_interface_v1_emit_baz_signal (
    FooChangingInterfaceV1 *object);



/* D-Bus method calls: */
void foo_changing_interface_v1_call_foo_method (
    FooChangingInterfaceV1 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_changing_interface_v1_call_foo_method_finish (
    FooChangingInterfaceV1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_changing_interface_v1_call_foo_method_sync (
    FooChangingInterfaceV1 *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_changing_interface_v1_call_bar_method (
    FooChangingInterfaceV1 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_changing_interface_v1_call_bar_method_finish (
    FooChangingInterfaceV1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_changing_interface_v1_call_bar_method_sync (
    FooChangingInterfaceV1 *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_changing_interface_v1_call_baz_method (
    FooChangingInterfaceV1 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_changing_interface_v1_call_baz_method_finish (
    FooChangingInterfaceV1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_changing_interface_v1_call_baz_method_sync (
    FooChangingInterfaceV1 *proxy,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define FOO_TYPE_CHANGING_INTERFACE_V1_PROXY (foo_changing_interface_v1_proxy_get_type ())
#define FOO_CHANGING_INTERFACE_V1_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_CHANGING_INTERFACE_V1_PROXY, FooChangingInterfaceV1Proxy))
#define FOO_CHANGING_INTERFACE_V1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_CHANGING_INTERFACE_V1_PROXY, FooChangingInterfaceV1ProxyClass))
#define FOO_CHANGING_INTERFACE_V1_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_CHANGING_INTERFACE_V1_PROXY, FooChangingInterfaceV1ProxyClass))
#define FOO_IS_CHANGING_INTERFACE_V1_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_CHANGING_INTERFACE_V1_PROXY))
#define FOO_IS_CHANGING_INTERFACE_V1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_CHANGING_INTERFACE_V1_PROXY))

typedef struct _FooChangingInterfaceV1Proxy FooChangingInterfaceV1Proxy;
typedef struct _FooChangingInterfaceV1ProxyClass FooChangingInterfaceV1ProxyClass;
typedef struct _FooChangingInterfaceV1ProxyPrivate FooChangingInterfaceV1ProxyPrivate;

struct _FooChangingInterfaceV1Proxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooChangingInterfaceV1ProxyPrivate *priv;
};

struct _FooChangingInterfaceV1ProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_changing_interface_v1_proxy_get_type (void) G_GNUC_CONST;

void foo_changing_interface_v1_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooChangingInterfaceV1 *foo_changing_interface_v1_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooChangingInterfaceV1 *foo_changing_interface_v1_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_changing_interface_v1_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooChangingInterfaceV1 *foo_changing_interface_v1_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooChangingInterfaceV1 *foo_changing_interface_v1_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_CHANGING_INTERFACE_V1_SKELETON (foo_changing_interface_v1_skeleton_get_type ())
#define FOO_CHANGING_INTERFACE_V1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_CHANGING_INTERFACE_V1_SKELETON, FooChangingInterfaceV1Skeleton))
#define FOO_CHANGING_INTERFACE_V1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_CHANGING_INTERFACE_V1_SKELETON, FooChangingInterfaceV1SkeletonClass))
#define FOO_CHANGING_INTERFACE_V1_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_CHANGING_INTERFACE_V1_SKELETON, FooChangingInterfaceV1SkeletonClass))
#define FOO_IS_CHANGING_INTERFACE_V1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_CHANGING_INTERFACE_V1_SKELETON))
#define FOO_IS_CHANGING_INTERFACE_V1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_CHANGING_INTERFACE_V1_SKELETON))

typedef struct _FooChangingInterfaceV1Skeleton FooChangingInterfaceV1Skeleton;
typedef struct _FooChangingInterfaceV1SkeletonClass FooChangingInterfaceV1SkeletonClass;
typedef struct _FooChangingInterfaceV1SkeletonPrivate FooChangingInterfaceV1SkeletonPrivate;

struct _FooChangingInterfaceV1Skeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooChangingInterfaceV1SkeletonPrivate *priv;
};

struct _FooChangingInterfaceV1SkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_changing_interface_v1_skeleton_get_type (void) G_GNUC_CONST;

FooChangingInterfaceV1 *foo_changing_interface_v1_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for ChangingInterfaceV2 */

#define FOO_TYPE_CHANGING_INTERFACE_V2 (foo_changing_interface_v2_get_type ())
#define FOO_CHANGING_INTERFACE_V2(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_CHANGING_INTERFACE_V2, FooChangingInterfaceV2))
#define FOO_IS_CHANGING_INTERFACE_V2(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_CHANGING_INTERFACE_V2))
#define FOO_CHANGING_INTERFACE_V2_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_CHANGING_INTERFACE_V2, FooChangingInterfaceV2Iface))

struct _FooChangingInterfaceV2;
typedef struct _FooChangingInterfaceV2 FooChangingInterfaceV2;
typedef struct _FooChangingInterfaceV2Iface FooChangingInterfaceV2Iface;

struct _FooChangingInterfaceV2Iface
{
  GTypeInterface parent_iface;


  gboolean (*handle_bar_method) (
    FooChangingInterfaceV2 *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_baz_method) (
    FooChangingInterfaceV2 *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_foo_method) (
    FooChangingInterfaceV2 *object,
    GDBusMethodInvocation *invocation);

  void (*bar_signal) (
    FooChangingInterfaceV2 *object);

  void (*baz_signal) (
    FooChangingInterfaceV2 *object);

  void (*foo_signal) (
    FooChangingInterfaceV2 *object);

  gboolean (*handle_new_method_in2) (
    FooChangingInterfaceV2 *object,
    GDBusMethodInvocation *invocation);

  void (*new_signal_in2) (
    FooChangingInterfaceV2 *object);

};

GType foo_changing_interface_v2_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_changing_interface_v2_interface_info (void);
guint foo_changing_interface_v2_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_changing_interface_v2_complete_new_method_in2 (
    FooChangingInterfaceV2 *object,
    GDBusMethodInvocation *invocation);

void foo_changing_interface_v2_complete_baz_method (
    FooChangingInterfaceV2 *object,
    GDBusMethodInvocation *invocation);

void foo_changing_interface_v2_complete_bar_method (
    FooChangingInterfaceV2 *object,
    GDBusMethodInvocation *invocation);

void foo_changing_interface_v2_complete_foo_method (
    FooChangingInterfaceV2 *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void foo_changing_interface_v2_emit_new_signal_in2 (
    FooChangingInterfaceV2 *object);

void foo_changing_interface_v2_emit_baz_signal (
    FooChangingInterfaceV2 *object);

void foo_changing_interface_v2_emit_bar_signal (
    FooChangingInterfaceV2 *object);

void foo_changing_interface_v2_emit_foo_signal (
    FooChangingInterfaceV2 *object);



/* D-Bus method calls: */
void foo_changing_interface_v2_call_new_method_in2 (
    FooChangingInterfaceV2 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_changing_interface_v2_call_new_method_in2_finish (
    FooChangingInterfaceV2 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_changing_interface_v2_call_new_method_in2_sync (
    FooChangingInterfaceV2 *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_changing_interface_v2_call_baz_method (
    FooChangingInterfaceV2 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_changing_interface_v2_call_baz_method_finish (
    FooChangingInterfaceV2 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_changing_interface_v2_call_baz_method_sync (
    FooChangingInterfaceV2 *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_changing_interface_v2_call_bar_method (
    FooChangingInterfaceV2 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_changing_interface_v2_call_bar_method_finish (
    FooChangingInterfaceV2 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_changing_interface_v2_call_bar_method_sync (
    FooChangingInterfaceV2 *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_changing_interface_v2_call_foo_method (
    FooChangingInterfaceV2 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_changing_interface_v2_call_foo_method_finish (
    FooChangingInterfaceV2 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_changing_interface_v2_call_foo_method_sync (
    FooChangingInterfaceV2 *proxy,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define FOO_TYPE_CHANGING_INTERFACE_V2_PROXY (foo_changing_interface_v2_proxy_get_type ())
#define FOO_CHANGING_INTERFACE_V2_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_CHANGING_INTERFACE_V2_PROXY, FooChangingInterfaceV2Proxy))
#define FOO_CHANGING_INTERFACE_V2_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_CHANGING_INTERFACE_V2_PROXY, FooChangingInterfaceV2ProxyClass))
#define FOO_CHANGING_INTERFACE_V2_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_CHANGING_INTERFACE_V2_PROXY, FooChangingInterfaceV2ProxyClass))
#define FOO_IS_CHANGING_INTERFACE_V2_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_CHANGING_INTERFACE_V2_PROXY))
#define FOO_IS_CHANGING_INTERFACE_V2_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_CHANGING_INTERFACE_V2_PROXY))

typedef struct _FooChangingInterfaceV2Proxy FooChangingInterfaceV2Proxy;
typedef struct _FooChangingInterfaceV2ProxyClass FooChangingInterfaceV2ProxyClass;
typedef struct _FooChangingInterfaceV2ProxyPrivate FooChangingInterfaceV2ProxyPrivate;

struct _FooChangingInterfaceV2Proxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooChangingInterfaceV2ProxyPrivate *priv;
};

struct _FooChangingInterfaceV2ProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_changing_interface_v2_proxy_get_type (void) G_GNUC_CONST;

void foo_changing_interface_v2_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooChangingInterfaceV2 *foo_changing_interface_v2_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooChangingInterfaceV2 *foo_changing_interface_v2_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_changing_interface_v2_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooChangingInterfaceV2 *foo_changing_interface_v2_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooChangingInterfaceV2 *foo_changing_interface_v2_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_CHANGING_INTERFACE_V2_SKELETON (foo_changing_interface_v2_skeleton_get_type ())
#define FOO_CHANGING_INTERFACE_V2_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_CHANGING_INTERFACE_V2_SKELETON, FooChangingInterfaceV2Skeleton))
#define FOO_CHANGING_INTERFACE_V2_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_CHANGING_INTERFACE_V2_SKELETON, FooChangingInterfaceV2SkeletonClass))
#define FOO_CHANGING_INTERFACE_V2_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_CHANGING_INTERFACE_V2_SKELETON, FooChangingInterfaceV2SkeletonClass))
#define FOO_IS_CHANGING_INTERFACE_V2_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_CHANGING_INTERFACE_V2_SKELETON))
#define FOO_IS_CHANGING_INTERFACE_V2_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_CHANGING_INTERFACE_V2_SKELETON))

typedef struct _FooChangingInterfaceV2Skeleton FooChangingInterfaceV2Skeleton;
typedef struct _FooChangingInterfaceV2SkeletonClass FooChangingInterfaceV2SkeletonClass;
typedef struct _FooChangingInterfaceV2SkeletonPrivate FooChangingInterfaceV2SkeletonPrivate;

struct _FooChangingInterfaceV2Skeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooChangingInterfaceV2SkeletonPrivate *priv;
};

struct _FooChangingInterfaceV2SkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_changing_interface_v2_skeleton_get_type (void) G_GNUC_CONST;

FooChangingInterfaceV2 *foo_changing_interface_v2_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for ChangingInterfaceV10 */

#define FOO_TYPE_CHANGING_INTERFACE_V10 (foo_changing_interface_v10_get_type ())
#define FOO_CHANGING_INTERFACE_V10(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_CHANGING_INTERFACE_V10, FooChangingInterfaceV10))
#define FOO_IS_CHANGING_INTERFACE_V10(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_CHANGING_INTERFACE_V10))
#define FOO_CHANGING_INTERFACE_V10_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_CHANGING_INTERFACE_V10, FooChangingInterfaceV10Iface))

struct _FooChangingInterfaceV10;
typedef struct _FooChangingInterfaceV10 FooChangingInterfaceV10;
typedef struct _FooChangingInterfaceV10Iface FooChangingInterfaceV10Iface;

struct _FooChangingInterfaceV10Iface
{
  GTypeInterface parent_iface;


  gboolean (*handle_bar_method) (
    FooChangingInterfaceV10 *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_baz_method) (
    FooChangingInterfaceV10 *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_foo_method) (
    FooChangingInterfaceV10 *object,
    GDBusMethodInvocation *invocation);

  void (*bar_signal) (
    FooChangingInterfaceV10 *object);

  void (*baz_signal) (
    FooChangingInterfaceV10 *object);

  void (*foo_signal) (
    FooChangingInterfaceV10 *object);

  gboolean (*handle_new_method_in2) (
    FooChangingInterfaceV10 *object,
    GDBusMethodInvocation *invocation);

  void (*new_signal_in2) (
    FooChangingInterfaceV10 *object);

  gboolean (*handle_added_method_in10) (
    FooChangingInterfaceV10 *object,
    GDBusMethodInvocation *invocation);

  void (*added_signal_in10) (
    FooChangingInterfaceV10 *object);

};

GType foo_changing_interface_v10_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_changing_interface_v10_interface_info (void);
guint foo_changing_interface_v10_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_changing_interface_v10_complete_added_method_in10 (
    FooChangingInterfaceV10 *object,
    GDBusMethodInvocation *invocation);

void foo_changing_interface_v10_complete_new_method_in2 (
    FooChangingInterfaceV10 *object,
    GDBusMethodInvocation *invocation);

void foo_changing_interface_v10_complete_baz_method (
    FooChangingInterfaceV10 *object,
    GDBusMethodInvocation *invocation);

void foo_changing_interface_v10_complete_bar_method (
    FooChangingInterfaceV10 *object,
    GDBusMethodInvocation *invocation);

void foo_changing_interface_v10_complete_foo_method (
    FooChangingInterfaceV10 *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void foo_changing_interface_v10_emit_added_signal_in10 (
    FooChangingInterfaceV10 *object);

void foo_changing_interface_v10_emit_new_signal_in2 (
    FooChangingInterfaceV10 *object);

void foo_changing_interface_v10_emit_baz_signal (
    FooChangingInterfaceV10 *object);

void foo_changing_interface_v10_emit_bar_signal (
    FooChangingInterfaceV10 *object);

void foo_changing_interface_v10_emit_foo_signal (
    FooChangingInterfaceV10 *object);



/* D-Bus method calls: */
void foo_changing_interface_v10_call_added_method_in10 (
    FooChangingInterfaceV10 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_changing_interface_v10_call_added_method_in10_finish (
    FooChangingInterfaceV10 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_changing_interface_v10_call_added_method_in10_sync (
    FooChangingInterfaceV10 *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_changing_interface_v10_call_new_method_in2 (
    FooChangingInterfaceV10 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_changing_interface_v10_call_new_method_in2_finish (
    FooChangingInterfaceV10 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_changing_interface_v10_call_new_method_in2_sync (
    FooChangingInterfaceV10 *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_changing_interface_v10_call_baz_method (
    FooChangingInterfaceV10 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_changing_interface_v10_call_baz_method_finish (
    FooChangingInterfaceV10 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_changing_interface_v10_call_baz_method_sync (
    FooChangingInterfaceV10 *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_changing_interface_v10_call_bar_method (
    FooChangingInterfaceV10 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_changing_interface_v10_call_bar_method_finish (
    FooChangingInterfaceV10 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_changing_interface_v10_call_bar_method_sync (
    FooChangingInterfaceV10 *proxy,
    GCancellable *cancellable,
    GError **error);

void foo_changing_interface_v10_call_foo_method (
    FooChangingInterfaceV10 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_changing_interface_v10_call_foo_method_finish (
    FooChangingInterfaceV10 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_changing_interface_v10_call_foo_method_sync (
    FooChangingInterfaceV10 *proxy,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define FOO_TYPE_CHANGING_INTERFACE_V10_PROXY (foo_changing_interface_v10_proxy_get_type ())
#define FOO_CHANGING_INTERFACE_V10_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_CHANGING_INTERFACE_V10_PROXY, FooChangingInterfaceV10Proxy))
#define FOO_CHANGING_INTERFACE_V10_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_CHANGING_INTERFACE_V10_PROXY, FooChangingInterfaceV10ProxyClass))
#define FOO_CHANGING_INTERFACE_V10_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_CHANGING_INTERFACE_V10_PROXY, FooChangingInterfaceV10ProxyClass))
#define FOO_IS_CHANGING_INTERFACE_V10_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_CHANGING_INTERFACE_V10_PROXY))
#define FOO_IS_CHANGING_INTERFACE_V10_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_CHANGING_INTERFACE_V10_PROXY))

typedef struct _FooChangingInterfaceV10Proxy FooChangingInterfaceV10Proxy;
typedef struct _FooChangingInterfaceV10ProxyClass FooChangingInterfaceV10ProxyClass;
typedef struct _FooChangingInterfaceV10ProxyPrivate FooChangingInterfaceV10ProxyPrivate;

struct _FooChangingInterfaceV10Proxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooChangingInterfaceV10ProxyPrivate *priv;
};

struct _FooChangingInterfaceV10ProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_changing_interface_v10_proxy_get_type (void) G_GNUC_CONST;

void foo_changing_interface_v10_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooChangingInterfaceV10 *foo_changing_interface_v10_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooChangingInterfaceV10 *foo_changing_interface_v10_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_changing_interface_v10_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooChangingInterfaceV10 *foo_changing_interface_v10_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooChangingInterfaceV10 *foo_changing_interface_v10_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_CHANGING_INTERFACE_V10_SKELETON (foo_changing_interface_v10_skeleton_get_type ())
#define FOO_CHANGING_INTERFACE_V10_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_CHANGING_INTERFACE_V10_SKELETON, FooChangingInterfaceV10Skeleton))
#define FOO_CHANGING_INTERFACE_V10_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_CHANGING_INTERFACE_V10_SKELETON, FooChangingInterfaceV10SkeletonClass))
#define FOO_CHANGING_INTERFACE_V10_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_CHANGING_INTERFACE_V10_SKELETON, FooChangingInterfaceV10SkeletonClass))
#define FOO_IS_CHANGING_INTERFACE_V10_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_CHANGING_INTERFACE_V10_SKELETON))
#define FOO_IS_CHANGING_INTERFACE_V10_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_CHANGING_INTERFACE_V10_SKELETON))

typedef struct _FooChangingInterfaceV10Skeleton FooChangingInterfaceV10Skeleton;
typedef struct _FooChangingInterfaceV10SkeletonClass FooChangingInterfaceV10SkeletonClass;
typedef struct _FooChangingInterfaceV10SkeletonPrivate FooChangingInterfaceV10SkeletonPrivate;

struct _FooChangingInterfaceV10Skeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooChangingInterfaceV10SkeletonPrivate *priv;
};

struct _FooChangingInterfaceV10SkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_changing_interface_v10_skeleton_get_type (void) G_GNUC_CONST;

FooChangingInterfaceV10 *foo_changing_interface_v10_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for TestUglyCaseInterface */

#define FOO_TYPE_TEST_UGLY_CASE_INTERFACE (foo_test_ugly_case_interface_get_type ())
#define FOO_TEST_UGLY_CASE_INTERFACE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_TEST_UGLY_CASE_INTERFACE, FooTesTuglyCASEInterface))
#define FOO_IS_TEST_UGLY_CASE_INTERFACE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_TEST_UGLY_CASE_INTERFACE))
#define FOO_TEST_UGLY_CASE_INTERFACE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_TEST_UGLY_CASE_INTERFACE, FooTesTuglyCASEInterfaceIface))

struct _FooTesTuglyCASEInterface;
typedef struct _FooTesTuglyCASEInterface FooTesTuglyCASEInterface;
typedef struct _FooTesTuglyCASEInterfaceIface FooTesTuglyCASEInterfaceIface;

struct _FooTesTuglyCASEInterfaceIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_get_iscsi_servers) (
    FooTesTuglyCASEInterface *object,
    GDBusMethodInvocation *invocation);

  gint  (*get_ugly_name) (FooTesTuglyCASEInterface *object);

  void (*servers_updated_now) (
    FooTesTuglyCASEInterface *object);

};

GType foo_test_ugly_case_interface_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_test_ugly_case_interface_interface_info (void);
guint foo_test_ugly_case_interface_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_test_ugly_case_interface_complete_get_iscsi_servers (
    FooTesTuglyCASEInterface *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void foo_test_ugly_case_interface_emit_servers_updated_now (
    FooTesTuglyCASEInterface *object);



/* D-Bus method calls: */
void foo_test_ugly_case_interface_call_get_iscsi_servers (
    FooTesTuglyCASEInterface *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_test_ugly_case_interface_call_get_iscsi_servers_finish (
    FooTesTuglyCASEInterface *proxy,
    GAsyncResult *res,
    GError **error);

gboolean foo_test_ugly_case_interface_call_get_iscsi_servers_sync (
    FooTesTuglyCASEInterface *proxy,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
gint foo_test_ugly_case_interface_get_ugly_name (FooTesTuglyCASEInterface *object);
void foo_test_ugly_case_interface_set_ugly_name (FooTesTuglyCASEInterface *object, gint value);


/* ---- */

#define FOO_TYPE_TEST_UGLY_CASE_INTERFACE_PROXY (foo_test_ugly_case_interface_proxy_get_type ())
#define FOO_TEST_UGLY_CASE_INTERFACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_TEST_UGLY_CASE_INTERFACE_PROXY, FooTesTuglyCASEInterfaceProxy))
#define FOO_TEST_UGLY_CASE_INTERFACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_TEST_UGLY_CASE_INTERFACE_PROXY, FooTesTuglyCASEInterfaceProxyClass))
#define FOO_TEST_UGLY_CASE_INTERFACE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_TEST_UGLY_CASE_INTERFACE_PROXY, FooTesTuglyCASEInterfaceProxyClass))
#define FOO_IS_TEST_UGLY_CASE_INTERFACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_TEST_UGLY_CASE_INTERFACE_PROXY))
#define FOO_IS_TEST_UGLY_CASE_INTERFACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_TEST_UGLY_CASE_INTERFACE_PROXY))

typedef struct _FooTesTuglyCASEInterfaceProxy FooTesTuglyCASEInterfaceProxy;
typedef struct _FooTesTuglyCASEInterfaceProxyClass FooTesTuglyCASEInterfaceProxyClass;
typedef struct _FooTesTuglyCASEInterfaceProxyPrivate FooTesTuglyCASEInterfaceProxyPrivate;

struct _FooTesTuglyCASEInterfaceProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooTesTuglyCASEInterfaceProxyPrivate *priv;
};

struct _FooTesTuglyCASEInterfaceProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_test_ugly_case_interface_proxy_get_type (void) G_GNUC_CONST;

void foo_test_ugly_case_interface_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooTesTuglyCASEInterface *foo_test_ugly_case_interface_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooTesTuglyCASEInterface *foo_test_ugly_case_interface_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_test_ugly_case_interface_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooTesTuglyCASEInterface *foo_test_ugly_case_interface_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooTesTuglyCASEInterface *foo_test_ugly_case_interface_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_TEST_UGLY_CASE_INTERFACE_SKELETON (foo_test_ugly_case_interface_skeleton_get_type ())
#define FOO_TEST_UGLY_CASE_INTERFACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_TEST_UGLY_CASE_INTERFACE_SKELETON, FooTesTuglyCASEInterfaceSkeleton))
#define FOO_TEST_UGLY_CASE_INTERFACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_TEST_UGLY_CASE_INTERFACE_SKELETON, FooTesTuglyCASEInterfaceSkeletonClass))
#define FOO_TEST_UGLY_CASE_INTERFACE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_TEST_UGLY_CASE_INTERFACE_SKELETON, FooTesTuglyCASEInterfaceSkeletonClass))
#define FOO_IS_TEST_UGLY_CASE_INTERFACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_TEST_UGLY_CASE_INTERFACE_SKELETON))
#define FOO_IS_TEST_UGLY_CASE_INTERFACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_TEST_UGLY_CASE_INTERFACE_SKELETON))

typedef struct _FooTesTuglyCASEInterfaceSkeleton FooTesTuglyCASEInterfaceSkeleton;
typedef struct _FooTesTuglyCASEInterfaceSkeletonClass FooTesTuglyCASEInterfaceSkeletonClass;
typedef struct _FooTesTuglyCASEInterfaceSkeletonPrivate FooTesTuglyCASEInterfaceSkeletonPrivate;

struct _FooTesTuglyCASEInterfaceSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooTesTuglyCASEInterfaceSkeletonPrivate *priv;
};

struct _FooTesTuglyCASEInterfaceSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_test_ugly_case_interface_skeleton_get_type (void) G_GNUC_CONST;

FooTesTuglyCASEInterface *foo_test_ugly_case_interface_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for OldieInterface */

#define FOO_TYPE_OLDIE_INTERFACE (foo_oldie_interface_get_type ())
#define FOO_OLDIE_INTERFACE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_OLDIE_INTERFACE, FooOldieInterface))
#define FOO_IS_OLDIE_INTERFACE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_OLDIE_INTERFACE))
#define FOO_OLDIE_INTERFACE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_OLDIE_INTERFACE, FooOldieInterfaceIface))

struct _FooOldieInterface;
typedef struct _FooOldieInterface FooOldieInterface;
typedef struct _FooOldieInterfaceIface FooOldieInterfaceIface;

struct _FooOldieInterfaceIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_foo) (
    FooOldieInterface *object,
    GDBusMethodInvocation *invocation);

  gint  (*get_bat) (FooOldieInterface *object);

  void (*bar) (
    FooOldieInterface *object);

};

GType foo_oldie_interface_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_oldie_interface_interface_info (void);
guint foo_oldie_interface_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
G_GNUC_DEPRECATED void foo_oldie_interface_complete_foo (
    FooOldieInterface *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
G_GNUC_DEPRECATED void foo_oldie_interface_emit_bar (
    FooOldieInterface *object);



/* D-Bus method calls: */
G_GNUC_DEPRECATED void foo_oldie_interface_call_foo (
    FooOldieInterface *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

G_GNUC_DEPRECATED gboolean foo_oldie_interface_call_foo_finish (
    FooOldieInterface *proxy,
    GAsyncResult *res,
    GError **error);

G_GNUC_DEPRECATED gboolean foo_oldie_interface_call_foo_sync (
    FooOldieInterface *proxy,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
G_GNUC_DEPRECATED gint foo_oldie_interface_get_bat (FooOldieInterface *object);
G_GNUC_DEPRECATED void foo_oldie_interface_set_bat (FooOldieInterface *object, gint value);


/* ---- */

#define FOO_TYPE_OLDIE_INTERFACE_PROXY (foo_oldie_interface_proxy_get_type ())
#define FOO_OLDIE_INTERFACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_OLDIE_INTERFACE_PROXY, FooOldieInterfaceProxy))
#define FOO_OLDIE_INTERFACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_OLDIE_INTERFACE_PROXY, FooOldieInterfaceProxyClass))
#define FOO_OLDIE_INTERFACE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_OLDIE_INTERFACE_PROXY, FooOldieInterfaceProxyClass))
#define FOO_IS_OLDIE_INTERFACE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_OLDIE_INTERFACE_PROXY))
#define FOO_IS_OLDIE_INTERFACE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_OLDIE_INTERFACE_PROXY))

typedef struct _FooOldieInterfaceProxy FooOldieInterfaceProxy;
typedef struct _FooOldieInterfaceProxyClass FooOldieInterfaceProxyClass;
typedef struct _FooOldieInterfaceProxyPrivate FooOldieInterfaceProxyPrivate;

struct _FooOldieInterfaceProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooOldieInterfaceProxyPrivate *priv;
};

struct _FooOldieInterfaceProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_oldie_interface_proxy_get_type (void) G_GNUC_CONST;

G_GNUC_DEPRECATED void foo_oldie_interface_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
G_GNUC_DEPRECATED FooOldieInterface *foo_oldie_interface_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
G_GNUC_DEPRECATED FooOldieInterface *foo_oldie_interface_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

G_GNUC_DEPRECATED void foo_oldie_interface_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
G_GNUC_DEPRECATED FooOldieInterface *foo_oldie_interface_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
G_GNUC_DEPRECATED FooOldieInterface *foo_oldie_interface_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_OLDIE_INTERFACE_SKELETON (foo_oldie_interface_skeleton_get_type ())
#define FOO_OLDIE_INTERFACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_OLDIE_INTERFACE_SKELETON, FooOldieInterfaceSkeleton))
#define FOO_OLDIE_INTERFACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_OLDIE_INTERFACE_SKELETON, FooOldieInterfaceSkeletonClass))
#define FOO_OLDIE_INTERFACE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_OLDIE_INTERFACE_SKELETON, FooOldieInterfaceSkeletonClass))
#define FOO_IS_OLDIE_INTERFACE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_OLDIE_INTERFACE_SKELETON))
#define FOO_IS_OLDIE_INTERFACE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_OLDIE_INTERFACE_SKELETON))

typedef struct _FooOldieInterfaceSkeleton FooOldieInterfaceSkeleton;
typedef struct _FooOldieInterfaceSkeletonClass FooOldieInterfaceSkeletonClass;
typedef struct _FooOldieInterfaceSkeletonPrivate FooOldieInterfaceSkeletonPrivate;

struct _FooOldieInterfaceSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooOldieInterfaceSkeletonPrivate *priv;
};

struct _FooOldieInterfaceSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_oldie_interface_skeleton_get_type (void) G_GNUC_CONST;

G_GNUC_DEPRECATED FooOldieInterface *foo_oldie_interface_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for UnknownXmlTags */

#define FOO_TYPE_UNKNOWN_XML_TAGS (foo_unknown_xml_tags_get_type ())
#define FOO_UNKNOWN_XML_TAGS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_UNKNOWN_XML_TAGS, FooUnknownXmlTags))
#define FOO_IS_UNKNOWN_XML_TAGS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_UNKNOWN_XML_TAGS))
#define FOO_UNKNOWN_XML_TAGS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_UNKNOWN_XML_TAGS, FooUnknownXmlTagsIface))

struct _FooUnknownXmlTags;
typedef struct _FooUnknownXmlTags FooUnknownXmlTags;
typedef struct _FooUnknownXmlTagsIface FooUnknownXmlTagsIface;

struct _FooUnknownXmlTagsIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_can_set_timezone) (
    FooUnknownXmlTags *object,
    GDBusMethodInvocation *invocation);

  const gchar * (*get_some_property) (FooUnknownXmlTags *object);

  void (*some_signal) (
    FooUnknownXmlTags *object);

};

GType foo_unknown_xml_tags_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_unknown_xml_tags_interface_info (void);
guint foo_unknown_xml_tags_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_unknown_xml_tags_complete_can_set_timezone (
    FooUnknownXmlTags *object,
    GDBusMethodInvocation *invocation,
    gint value);



/* D-Bus signal emissions functions: */
void foo_unknown_xml_tags_emit_some_signal (
    FooUnknownXmlTags *object);



/* D-Bus method calls: */
void foo_unknown_xml_tags_call_can_set_timezone (
    FooUnknownXmlTags *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_unknown_xml_tags_call_can_set_timezone_finish (
    FooUnknownXmlTags *proxy,
    gint *out_value,
    GAsyncResult *res,
    GError **error);

gboolean foo_unknown_xml_tags_call_can_set_timezone_sync (
    FooUnknownXmlTags *proxy,
    gint *out_value,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
const gchar *foo_unknown_xml_tags_get_some_property (FooUnknownXmlTags *object);
gchar *foo_unknown_xml_tags_dup_some_property (FooUnknownXmlTags *object);
void foo_unknown_xml_tags_set_some_property (FooUnknownXmlTags *object, const gchar *value);


/* ---- */

#define FOO_TYPE_UNKNOWN_XML_TAGS_PROXY (foo_unknown_xml_tags_proxy_get_type ())
#define FOO_UNKNOWN_XML_TAGS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_UNKNOWN_XML_TAGS_PROXY, FooUnknownXmlTagsProxy))
#define FOO_UNKNOWN_XML_TAGS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_UNKNOWN_XML_TAGS_PROXY, FooUnknownXmlTagsProxyClass))
#define FOO_UNKNOWN_XML_TAGS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_UNKNOWN_XML_TAGS_PROXY, FooUnknownXmlTagsProxyClass))
#define FOO_IS_UNKNOWN_XML_TAGS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_UNKNOWN_XML_TAGS_PROXY))
#define FOO_IS_UNKNOWN_XML_TAGS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_UNKNOWN_XML_TAGS_PROXY))

typedef struct _FooUnknownXmlTagsProxy FooUnknownXmlTagsProxy;
typedef struct _FooUnknownXmlTagsProxyClass FooUnknownXmlTagsProxyClass;
typedef struct _FooUnknownXmlTagsProxyPrivate FooUnknownXmlTagsProxyPrivate;

struct _FooUnknownXmlTagsProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooUnknownXmlTagsProxyPrivate *priv;
};

struct _FooUnknownXmlTagsProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_unknown_xml_tags_proxy_get_type (void) G_GNUC_CONST;

void foo_unknown_xml_tags_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooUnknownXmlTags *foo_unknown_xml_tags_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooUnknownXmlTags *foo_unknown_xml_tags_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_unknown_xml_tags_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooUnknownXmlTags *foo_unknown_xml_tags_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooUnknownXmlTags *foo_unknown_xml_tags_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_UNKNOWN_XML_TAGS_SKELETON (foo_unknown_xml_tags_skeleton_get_type ())
#define FOO_UNKNOWN_XML_TAGS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_UNKNOWN_XML_TAGS_SKELETON, FooUnknownXmlTagsSkeleton))
#define FOO_UNKNOWN_XML_TAGS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_UNKNOWN_XML_TAGS_SKELETON, FooUnknownXmlTagsSkeletonClass))
#define FOO_UNKNOWN_XML_TAGS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_UNKNOWN_XML_TAGS_SKELETON, FooUnknownXmlTagsSkeletonClass))
#define FOO_IS_UNKNOWN_XML_TAGS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_UNKNOWN_XML_TAGS_SKELETON))
#define FOO_IS_UNKNOWN_XML_TAGS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_UNKNOWN_XML_TAGS_SKELETON))

typedef struct _FooUnknownXmlTagsSkeleton FooUnknownXmlTagsSkeleton;
typedef struct _FooUnknownXmlTagsSkeletonClass FooUnknownXmlTagsSkeletonClass;
typedef struct _FooUnknownXmlTagsSkeletonPrivate FooUnknownXmlTagsSkeletonPrivate;

struct _FooUnknownXmlTagsSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooUnknownXmlTagsSkeletonPrivate *priv;
};

struct _FooUnknownXmlTagsSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_unknown_xml_tags_skeleton_get_type (void) G_GNUC_CONST;

FooUnknownXmlTags *foo_unknown_xml_tags_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for FDPassing */

#define FOO_TYPE_FDPASSING (foo_fdpassing_get_type ())
#define FOO_FDPASSING(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_FDPASSING, FooFDPassing))
#define FOO_IS_FDPASSING(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_FDPASSING))
#define FOO_FDPASSING_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_FDPASSING, FooFDPassingIface))

struct _FooFDPassing;
typedef struct _FooFDPassing FooFDPassing;
typedef struct _FooFDPassingIface FooFDPassingIface;

struct _FooFDPassingIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_hello_fd) (
    FooFDPassing *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *greeting);

};

GType foo_fdpassing_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *foo_fdpassing_interface_info (void);
guint foo_fdpassing_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void foo_fdpassing_complete_hello_fd (
    FooFDPassing *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *response);



/* D-Bus method calls: */
void foo_fdpassing_call_hello_fd (
    FooFDPassing *proxy,
    const gchar *greeting,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean foo_fdpassing_call_hello_fd_finish (
    FooFDPassing *proxy,
    gchar **out_response,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean foo_fdpassing_call_hello_fd_sync (
    FooFDPassing *proxy,
    const gchar *greeting,
    GUnixFDList  *fd_list,
    gchar **out_response,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define FOO_TYPE_FDPASSING_PROXY (foo_fdpassing_proxy_get_type ())
#define FOO_FDPASSING_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_FDPASSING_PROXY, FooFDPassingProxy))
#define FOO_FDPASSING_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_FDPASSING_PROXY, FooFDPassingProxyClass))
#define FOO_FDPASSING_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_FDPASSING_PROXY, FooFDPassingProxyClass))
#define FOO_IS_FDPASSING_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_FDPASSING_PROXY))
#define FOO_IS_FDPASSING_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_FDPASSING_PROXY))

typedef struct _FooFDPassingProxy FooFDPassingProxy;
typedef struct _FooFDPassingProxyClass FooFDPassingProxyClass;
typedef struct _FooFDPassingProxyPrivate FooFDPassingProxyPrivate;

struct _FooFDPassingProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  FooFDPassingProxyPrivate *priv;
};

struct _FooFDPassingProxyClass
{
  GDBusProxyClass parent_class;
};

GType foo_fdpassing_proxy_get_type (void) G_GNUC_CONST;

void foo_fdpassing_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooFDPassing *foo_fdpassing_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
FooFDPassing *foo_fdpassing_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void foo_fdpassing_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
FooFDPassing *foo_fdpassing_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
FooFDPassing *foo_fdpassing_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define FOO_TYPE_FDPASSING_SKELETON (foo_fdpassing_skeleton_get_type ())
#define FOO_FDPASSING_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_FDPASSING_SKELETON, FooFDPassingSkeleton))
#define FOO_FDPASSING_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_FDPASSING_SKELETON, FooFDPassingSkeletonClass))
#define FOO_FDPASSING_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_FDPASSING_SKELETON, FooFDPassingSkeletonClass))
#define FOO_IS_FDPASSING_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_FDPASSING_SKELETON))
#define FOO_IS_FDPASSING_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_FDPASSING_SKELETON))

typedef struct _FooFDPassingSkeleton FooFDPassingSkeleton;
typedef struct _FooFDPassingSkeletonClass FooFDPassingSkeletonClass;
typedef struct _FooFDPassingSkeletonPrivate FooFDPassingSkeletonPrivate;

struct _FooFDPassingSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  FooFDPassingSkeletonPrivate *priv;
};

struct _FooFDPassingSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType foo_fdpassing_skeleton_get_type (void) G_GNUC_CONST;

FooFDPassing *foo_fdpassing_skeleton_new (void);


/* ---- */

#define FOO_TYPE_OBJECT (foo_object_get_type ())
#define FOO_OBJECT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_OBJECT, FooObject))
#define FOO_IS_OBJECT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_OBJECT))
#define FOO_OBJECT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), FOO_TYPE_OBJECT, FooObject))

struct _FooObject;
typedef struct _FooObject FooObject;
typedef struct _FooObjectIface FooObjectIface;

struct _FooObjectIface
{
  GTypeInterface parent_iface;
};

GType foo_object_get_type (void) G_GNUC_CONST;

FooBar *foo_object_get_bar (FooObject *object);
FooBarFrobnicator *foo_object_get_bar_frobnicator (FooObject *object);
FooBaz *foo_object_get_baz (FooObject *object);
FooComAcmeCoyote *foo_object_get_com_acme_coyote (FooObject *object);
FooRocket123 *foo_object_get_rocket123 (FooObject *object);
FooBat *foo_object_get_bat (FooObject *object);
FooAuthorize *foo_object_get_authorize (FooObject *object);
FooMethodThreads *foo_object_get_method_threads (FooObject *object);
FooInlineDocs *foo_object_get_inline_docs (FooObject *object);
FooChangingInterfaceV1 *foo_object_get_changing_interface_v1 (FooObject *object);
FooChangingInterfaceV2 *foo_object_get_changing_interface_v2 (FooObject *object);
FooChangingInterfaceV10 *foo_object_get_changing_interface_v10 (FooObject *object);
FooTesTuglyCASEInterface *foo_object_get_test_ugly_case_interface (FooObject *object);
G_GNUC_DEPRECATED FooOldieInterface *foo_object_get_oldie_interface (FooObject *object);
FooUnknownXmlTags *foo_object_get_unknown_xml_tags (FooObject *object);
FooFDPassing *foo_object_get_fdpassing (FooObject *object);
FooBar *foo_object_peek_bar (FooObject *object);
FooBarFrobnicator *foo_object_peek_bar_frobnicator (FooObject *object);
FooBaz *foo_object_peek_baz (FooObject *object);
FooComAcmeCoyote *foo_object_peek_com_acme_coyote (FooObject *object);
FooRocket123 *foo_object_peek_rocket123 (FooObject *object);
FooBat *foo_object_peek_bat (FooObject *object);
FooAuthorize *foo_object_peek_authorize (FooObject *object);
FooMethodThreads *foo_object_peek_method_threads (FooObject *object);
FooInlineDocs *foo_object_peek_inline_docs (FooObject *object);
FooChangingInterfaceV1 *foo_object_peek_changing_interface_v1 (FooObject *object);
FooChangingInterfaceV2 *foo_object_peek_changing_interface_v2 (FooObject *object);
FooChangingInterfaceV10 *foo_object_peek_changing_interface_v10 (FooObject *object);
FooTesTuglyCASEInterface *foo_object_peek_test_ugly_case_interface (FooObject *object);
G_GNUC_DEPRECATED FooOldieInterface *foo_object_peek_oldie_interface (FooObject *object);
FooUnknownXmlTags *foo_object_peek_unknown_xml_tags (FooObject *object);
FooFDPassing *foo_object_peek_fdpassing (FooObject *object);

#define FOO_TYPE_OBJECT_PROXY (foo_object_proxy_get_type ())
#define FOO_OBJECT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_OBJECT_PROXY, FooObjectProxy))
#define FOO_OBJECT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_OBJECT_PROXY, FooObjectProxyClass))
#define FOO_OBJECT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_OBJECT_PROXY, FooObjectProxyClass))
#define FOO_IS_OBJECT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_OBJECT_PROXY))
#define FOO_IS_OBJECT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_OBJECT_PROXY))

typedef struct _FooObjectProxy FooObjectProxy;
typedef struct _FooObjectProxyClass FooObjectProxyClass;
typedef struct _FooObjectProxyPrivate FooObjectProxyPrivate;

struct _FooObjectProxy
{
  /*< private >*/
  GDBusObjectProxy parent_instance;
  FooObjectProxyPrivate *priv;
};

struct _FooObjectProxyClass
{
  GDBusObjectProxyClass parent_class;
};

GType foo_object_proxy_get_type (void) G_GNUC_CONST;
FooObjectProxy *foo_object_proxy_new (GDBusConnection *connection, const gchar *object_path);

#define FOO_TYPE_OBJECT_SKELETON (foo_object_skeleton_get_type ())
#define FOO_OBJECT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_OBJECT_SKELETON, FooObjectSkeleton))
#define FOO_OBJECT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_OBJECT_SKELETON, FooObjectSkeletonClass))
#define FOO_OBJECT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_OBJECT_SKELETON, FooObjectSkeletonClass))
#define FOO_IS_OBJECT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_OBJECT_SKELETON))
#define FOO_IS_OBJECT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_OBJECT_SKELETON))

typedef struct _FooObjectSkeleton FooObjectSkeleton;
typedef struct _FooObjectSkeletonClass FooObjectSkeletonClass;
typedef struct _FooObjectSkeletonPrivate FooObjectSkeletonPrivate;

struct _FooObjectSkeleton
{
  /*< private >*/
  GDBusObjectSkeleton parent_instance;
  FooObjectSkeletonPrivate *priv;
};

struct _FooObjectSkeletonClass
{
  GDBusObjectSkeletonClass parent_class;
};

GType foo_object_skeleton_get_type (void) G_GNUC_CONST;
FooObjectSkeleton *foo_object_skeleton_new (const gchar *object_path);
void foo_object_skeleton_set_bar (FooObjectSkeleton *object, FooBar *interface_);
void foo_object_skeleton_set_bar_frobnicator (FooObjectSkeleton *object, FooBarFrobnicator *interface_);
void foo_object_skeleton_set_baz (FooObjectSkeleton *object, FooBaz *interface_);
void foo_object_skeleton_set_com_acme_coyote (FooObjectSkeleton *object, FooComAcmeCoyote *interface_);
void foo_object_skeleton_set_rocket123 (FooObjectSkeleton *object, FooRocket123 *interface_);
void foo_object_skeleton_set_bat (FooObjectSkeleton *object, FooBat *interface_);
void foo_object_skeleton_set_authorize (FooObjectSkeleton *object, FooAuthorize *interface_);
void foo_object_skeleton_set_method_threads (FooObjectSkeleton *object, FooMethodThreads *interface_);
void foo_object_skeleton_set_inline_docs (FooObjectSkeleton *object, FooInlineDocs *interface_);
void foo_object_skeleton_set_changing_interface_v1 (FooObjectSkeleton *object, FooChangingInterfaceV1 *interface_);
void foo_object_skeleton_set_changing_interface_v2 (FooObjectSkeleton *object, FooChangingInterfaceV2 *interface_);
void foo_object_skeleton_set_changing_interface_v10 (FooObjectSkeleton *object, FooChangingInterfaceV10 *interface_);
void foo_object_skeleton_set_test_ugly_case_interface (FooObjectSkeleton *object, FooTesTuglyCASEInterface *interface_);
G_GNUC_DEPRECATED void foo_object_skeleton_set_oldie_interface (FooObjectSkeleton *object, FooOldieInterface *interface_);
void foo_object_skeleton_set_unknown_xml_tags (FooObjectSkeleton *object, FooUnknownXmlTags *interface_);
void foo_object_skeleton_set_fdpassing (FooObjectSkeleton *object, FooFDPassing *interface_);

/* ---- */

#define FOO_TYPE_OBJECT_MANAGER_CLIENT (foo_object_manager_client_get_type ())
#define FOO_OBJECT_MANAGER_CLIENT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), FOO_TYPE_OBJECT_MANAGER_CLIENT, FooObjectManagerClient))
#define FOO_OBJECT_MANAGER_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), FOO_TYPE_OBJECT_MANAGER_CLIENT, FooObjectManagerClientClass))
#define FOO_OBJECT_MANAGER_CLIENT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), FOO_TYPE_OBJECT_MANAGER_CLIENT, FooObjectManagerClientClass))
#define FOO_IS_OBJECT_MANAGER_CLIENT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), FOO_TYPE_OBJECT_MANAGER_CLIENT))
#define FOO_IS_OBJECT_MANAGER_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), FOO_TYPE_OBJECT_MANAGER_CLIENT))

typedef struct _FooObjectManagerClient FooObjectManagerClient;
typedef struct _FooObjectManagerClientClass FooObjectManagerClientClass;
typedef struct _FooObjectManagerClientPrivate FooObjectManagerClientPrivate;

struct _FooObjectManagerClient
{
  /*< private >*/
  GDBusObjectManagerClient parent_instance;
  FooObjectManagerClientPrivate *priv;
};

struct _FooObjectManagerClientClass
{
  GDBusObjectManagerClientClass parent_class;
};

GType foo_object_manager_client_get_type (void) G_GNUC_CONST;

GType foo_object_manager_client_get_proxy_type (GDBusObjectManagerClient *manager, const gchar *object_path, const gchar *interface_name, gpointer user_data);

void foo_object_manager_client_new (
    GDBusConnection        *connection,
    GDBusObjectManagerClientFlags  flags,
    const gchar            *name,
    const gchar            *object_path,
    GCancellable           *cancellable,
    GAsyncReadyCallback     callback,
    gpointer                user_data);
GDBusObjectManager *foo_object_manager_client_new_finish (
    GAsyncResult        *res,
    GError             **error);
GDBusObjectManager *foo_object_manager_client_new_sync (
    GDBusConnection        *connection,
    GDBusObjectManagerClientFlags  flags,
    const gchar            *name,
    const gchar            *object_path,
    GCancellable           *cancellable,
    GError                **error);

void foo_object_manager_client_new_for_bus (
    GBusType                bus_type,
    GDBusObjectManagerClientFlags  flags,
    const gchar            *name,
    const gchar            *object_path,
    GCancellable           *cancellable,
    GAsyncReadyCallback     callback,
    gpointer                user_data);
GDBusObjectManager *foo_object_manager_client_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
GDBusObjectManager *foo_object_manager_client_new_for_bus_sync (
    GBusType                bus_type,
    GDBusObjectManagerClientFlags  flags,
    const gchar            *name,
    const gchar            *object_path,
    GCancellable           *cancellable,
    GError                **error);


G_END_DECLS

#endif /* __GDBUS_TEST_CODEGEN_GENERATED_H__ */
