path: root/include/generated-code.h

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

#ifndef __GENERATED_CODE_H__
#define __GENERATED_CODE_H__

#include <gio/gio.h>

G_BEGIN_DECLS


/* ------------------------------------------------------------------------ */
/* Declarations for org.bluez.Adapter1 */

#define TYPE_ADAPTER1 (adapter1_get_type ())
#define ADAPTER1(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_ADAPTER1, Adapter1))
#define IS_ADAPTER1(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_ADAPTER1))
#define ADAPTER1_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_ADAPTER1, Adapter1Iface))

struct _Adapter1;
typedef struct _Adapter1 Adapter1;
typedef struct _Adapter1Iface Adapter1Iface;

struct _Adapter1Iface
{
  GTypeInterface parent_iface;


  gboolean (*handle_remove_device) (
    Adapter1 *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_device);

  gboolean (*handle_start_discovery) (
    Adapter1 *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_stop_discovery) (
    Adapter1 *object,
    GDBusMethodInvocation *invocation);

  const gchar * (*get_address) (Adapter1 *object);

  const gchar * (*get_alias) (Adapter1 *object);

  guint  (*get_class) (Adapter1 *object);

  gboolean  (*get_discoverable) (Adapter1 *object);

  guint  (*get_discoverable_timeout) (Adapter1 *object);

  gboolean  (*get_discovering) (Adapter1 *object);

  const gchar * (*get_modalias) (Adapter1 *object);

  const gchar * (*get_name) (Adapter1 *object);

  gboolean  (*get_pairable) (Adapter1 *object);

  guint  (*get_pairable_timeout) (Adapter1 *object);

  gboolean  (*get_powered) (Adapter1 *object);

  const gchar *const * (*get_uuids) (Adapter1 *object);

};

GType adapter1_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *adapter1_interface_info (void);
guint adapter1_override_properties (GObjectClass *klass, guint property_id_begin);


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

void adapter1_complete_stop_discovery (
    Adapter1 *object,
    GDBusMethodInvocation *invocation);

void adapter1_complete_remove_device (
    Adapter1 *object,
    GDBusMethodInvocation *invocation);



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

gboolean adapter1_call_start_discovery_finish (
    Adapter1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean adapter1_call_start_discovery_sync (
    Adapter1 *proxy,
    GCancellable *cancellable,
    GError **error);

void adapter1_call_stop_discovery (
    Adapter1 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean adapter1_call_stop_discovery_finish (
    Adapter1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean adapter1_call_stop_discovery_sync (
    Adapter1 *proxy,
    GCancellable *cancellable,
    GError **error);

void adapter1_call_remove_device (
    Adapter1 *proxy,
    const gchar *arg_device,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean adapter1_call_remove_device_finish (
    Adapter1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean adapter1_call_remove_device_sync (
    Adapter1 *proxy,
    const gchar *arg_device,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
const gchar *adapter1_get_address (Adapter1 *object);
gchar *adapter1_dup_address (Adapter1 *object);
void adapter1_set_address (Adapter1 *object, const gchar *value);

const gchar *adapter1_get_name (Adapter1 *object);
gchar *adapter1_dup_name (Adapter1 *object);
void adapter1_set_name (Adapter1 *object, const gchar *value);

const gchar *adapter1_get_alias (Adapter1 *object);
gchar *adapter1_dup_alias (Adapter1 *object);
void adapter1_set_alias (Adapter1 *object, const gchar *value);

guint adapter1_get_class (Adapter1 *object);
void adapter1_set_class (Adapter1 *object, guint value);

gboolean adapter1_get_powered (Adapter1 *object);
void adapter1_set_powered (Adapter1 *object, gboolean value);

gboolean adapter1_get_discoverable (Adapter1 *object);
void adapter1_set_discoverable (Adapter1 *object, gboolean value);

guint adapter1_get_discoverable_timeout (Adapter1 *object);
void adapter1_set_discoverable_timeout (Adapter1 *object, guint value);

gboolean adapter1_get_pairable (Adapter1 *object);
void adapter1_set_pairable (Adapter1 *object, gboolean value);

guint adapter1_get_pairable_timeout (Adapter1 *object);
void adapter1_set_pairable_timeout (Adapter1 *object, guint value);

gboolean adapter1_get_discovering (Adapter1 *object);
void adapter1_set_discovering (Adapter1 *object, gboolean value);

const gchar *const *adapter1_get_uuids (Adapter1 *object);
gchar **adapter1_dup_uuids (Adapter1 *object);
void adapter1_set_uuids (Adapter1 *object, const gchar *const *value);

const gchar *adapter1_get_modalias (Adapter1 *object);
gchar *adapter1_dup_modalias (Adapter1 *object);
void adapter1_set_modalias (Adapter1 *object, const gchar *value);


/* ---- */

#define TYPE_ADAPTER1_PROXY (adapter1_proxy_get_type ())
#define ADAPTER1_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_ADAPTER1_PROXY, Adapter1Proxy))
#define ADAPTER1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_ADAPTER1_PROXY, Adapter1ProxyClass))
#define ADAPTER1_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_ADAPTER1_PROXY, Adapter1ProxyClass))
#define IS_ADAPTER1_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_ADAPTER1_PROXY))
#define IS_ADAPTER1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_ADAPTER1_PROXY))

typedef struct _Adapter1Proxy Adapter1Proxy;
typedef struct _Adapter1ProxyClass Adapter1ProxyClass;
typedef struct _Adapter1ProxyPrivate Adapter1ProxyPrivate;

struct _Adapter1Proxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  Adapter1ProxyPrivate *priv;
};

struct _Adapter1ProxyClass
{
  GDBusProxyClass parent_class;
};

GType adapter1_proxy_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (Adapter1Proxy, g_object_unref)
#endif

void adapter1_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
Adapter1 *adapter1_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
Adapter1 *adapter1_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void adapter1_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
Adapter1 *adapter1_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
Adapter1 *adapter1_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define TYPE_ADAPTER1_SKELETON (adapter1_skeleton_get_type ())
#define ADAPTER1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_ADAPTER1_SKELETON, Adapter1Skeleton))
#define ADAPTER1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_ADAPTER1_SKELETON, Adapter1SkeletonClass))
#define ADAPTER1_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_ADAPTER1_SKELETON, Adapter1SkeletonClass))
#define IS_ADAPTER1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_ADAPTER1_SKELETON))
#define IS_ADAPTER1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_ADAPTER1_SKELETON))

typedef struct _Adapter1Skeleton Adapter1Skeleton;
typedef struct _Adapter1SkeletonClass Adapter1SkeletonClass;
typedef struct _Adapter1SkeletonPrivate Adapter1SkeletonPrivate;

struct _Adapter1Skeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  Adapter1SkeletonPrivate *priv;
};

struct _Adapter1SkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType adapter1_skeleton_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (Adapter1Skeleton, g_object_unref)
#endif

Adapter1 *adapter1_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.bluez.Device1 */

#define TYPE_DEVICE1 (device1_get_type ())
#define DEVICE1(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_DEVICE1, Device1))
#define IS_DEVICE1(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_DEVICE1))
#define DEVICE1_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_DEVICE1, Device1Iface))

struct _Device1;
typedef struct _Device1 Device1;
typedef struct _Device1Iface Device1Iface;

struct _Device1Iface
{
  GTypeInterface parent_iface;


  gboolean (*handle_cancel_pairing) (
    Device1 *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_connect) (
    Device1 *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_connect_profile) (
    Device1 *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_UUID);

  gboolean (*handle_disconnect) (
    Device1 *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_disconnect_profile) (
    Device1 *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_UUID);

  gboolean (*handle_pair) (
    Device1 *object,
    GDBusMethodInvocation *invocation);

  const gchar * (*get_adapter) (Device1 *object);

  const gchar * (*get_address) (Device1 *object);

  const gchar * (*get_alias) (Device1 *object);

  guint16  (*get_appearance) (Device1 *object);

  gboolean  (*get_blocked) (Device1 *object);

  guint  (*get_class) (Device1 *object);

  gboolean  (*get_connected) (Device1 *object);

  const gchar * (*get_icon) (Device1 *object);

  gboolean  (*get_legacy_pairing) (Device1 *object);

  GVariant * (*get_manufacturer_data) (Device1 *object);

  const gchar * (*get_modalias) (Device1 *object);

  const gchar * (*get_name) (Device1 *object);

  gboolean  (*get_paired) (Device1 *object);

  gint16  (*get_rssi) (Device1 *object);

  GVariant * (*get_service_data) (Device1 *object);

  gboolean  (*get_services_resolved) (Device1 *object);

  gboolean  (*get_trusted) (Device1 *object);

  gint16  (*get_tx_power) (Device1 *object);

  const gchar *const * (*get_uuids) (Device1 *object);

};

GType device1_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *device1_interface_info (void);
guint device1_override_properties (GObjectClass *klass, guint property_id_begin);


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

void device1_complete_connect (
    Device1 *object,
    GDBusMethodInvocation *invocation);

void device1_complete_connect_profile (
    Device1 *object,
    GDBusMethodInvocation *invocation);

void device1_complete_disconnect_profile (
    Device1 *object,
    GDBusMethodInvocation *invocation);

void device1_complete_pair (
    Device1 *object,
    GDBusMethodInvocation *invocation);

void device1_complete_cancel_pairing (
    Device1 *object,
    GDBusMethodInvocation *invocation);



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

gboolean device1_call_disconnect_finish (
    Device1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean device1_call_disconnect_sync (
    Device1 *proxy,
    GCancellable *cancellable,
    GError **error);

void device1_call_connect (
    Device1 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean device1_call_connect_finish (
    Device1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean device1_call_connect_sync (
    Device1 *proxy,
    GCancellable *cancellable,
    GError **error);

void device1_call_connect_profile (
    Device1 *proxy,
    const gchar *arg_UUID,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean device1_call_connect_profile_finish (
    Device1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean device1_call_connect_profile_sync (
    Device1 *proxy,
    const gchar *arg_UUID,
    GCancellable *cancellable,
    GError **error);

void device1_call_disconnect_profile (
    Device1 *proxy,
    const gchar *arg_UUID,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean device1_call_disconnect_profile_finish (
    Device1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean device1_call_disconnect_profile_sync (
    Device1 *proxy,
    const gchar *arg_UUID,
    GCancellable *cancellable,
    GError **error);

void device1_call_pair (
    Device1 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean device1_call_pair_finish (
    Device1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean device1_call_pair_sync (
    Device1 *proxy,
    GCancellable *cancellable,
    GError **error);

void device1_call_cancel_pairing (
    Device1 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean device1_call_cancel_pairing_finish (
    Device1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean device1_call_cancel_pairing_sync (
    Device1 *proxy,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
const gchar *device1_get_address (Device1 *object);
gchar *device1_dup_address (Device1 *object);
void device1_set_address (Device1 *object, const gchar *value);

const gchar *device1_get_name (Device1 *object);
gchar *device1_dup_name (Device1 *object);
void device1_set_name (Device1 *object, const gchar *value);

const gchar *device1_get_alias (Device1 *object);
gchar *device1_dup_alias (Device1 *object);
void device1_set_alias (Device1 *object, const gchar *value);

guint device1_get_class (Device1 *object);
void device1_set_class (Device1 *object, guint value);

guint16 device1_get_appearance (Device1 *object);
void device1_set_appearance (Device1 *object, guint16 value);

const gchar *device1_get_icon (Device1 *object);
gchar *device1_dup_icon (Device1 *object);
void device1_set_icon (Device1 *object, const gchar *value);

gboolean device1_get_paired (Device1 *object);
void device1_set_paired (Device1 *object, gboolean value);

gboolean device1_get_trusted (Device1 *object);
void device1_set_trusted (Device1 *object, gboolean value);

gboolean device1_get_blocked (Device1 *object);
void device1_set_blocked (Device1 *object, gboolean value);

gboolean device1_get_legacy_pairing (Device1 *object);
void device1_set_legacy_pairing (Device1 *object, gboolean value);

gint16 device1_get_rssi (Device1 *object);
void device1_set_rssi (Device1 *object, gint16 value);

gboolean device1_get_connected (Device1 *object);
void device1_set_connected (Device1 *object, gboolean value);

const gchar *const *device1_get_uuids (Device1 *object);
gchar **device1_dup_uuids (Device1 *object);
void device1_set_uuids (Device1 *object, const gchar *const *value);

const gchar *device1_get_modalias (Device1 *object);
gchar *device1_dup_modalias (Device1 *object);
void device1_set_modalias (Device1 *object, const gchar *value);

const gchar *device1_get_adapter (Device1 *object);
gchar *device1_dup_adapter (Device1 *object);
void device1_set_adapter (Device1 *object, const gchar *value);

GVariant *device1_get_manufacturer_data (Device1 *object);
GVariant *device1_dup_manufacturer_data (Device1 *object);
void device1_set_manufacturer_data (Device1 *object, GVariant *value);

GVariant *device1_get_service_data (Device1 *object);
GVariant *device1_dup_service_data (Device1 *object);
void device1_set_service_data (Device1 *object, GVariant *value);

gint16 device1_get_tx_power (Device1 *object);
void device1_set_tx_power (Device1 *object, gint16 value);

gboolean device1_get_services_resolved (Device1 *object);
void device1_set_services_resolved (Device1 *object, gboolean value);


/* ---- */

#define TYPE_DEVICE1_PROXY (device1_proxy_get_type ())
#define DEVICE1_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_DEVICE1_PROXY, Device1Proxy))
#define DEVICE1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_DEVICE1_PROXY, Device1ProxyClass))
#define DEVICE1_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_DEVICE1_PROXY, Device1ProxyClass))
#define IS_DEVICE1_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_DEVICE1_PROXY))
#define IS_DEVICE1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_DEVICE1_PROXY))

typedef struct _Device1Proxy Device1Proxy;
typedef struct _Device1ProxyClass Device1ProxyClass;
typedef struct _Device1ProxyPrivate Device1ProxyPrivate;

struct _Device1Proxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  Device1ProxyPrivate *priv;
};

struct _Device1ProxyClass
{
  GDBusProxyClass parent_class;
};

GType device1_proxy_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (Device1Proxy, g_object_unref)
#endif

void device1_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
Device1 *device1_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
Device1 *device1_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void device1_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
Device1 *device1_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
Device1 *device1_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define TYPE_DEVICE1_SKELETON (device1_skeleton_get_type ())
#define DEVICE1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_DEVICE1_SKELETON, Device1Skeleton))
#define DEVICE1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_DEVICE1_SKELETON, Device1SkeletonClass))
#define DEVICE1_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_DEVICE1_SKELETON, Device1SkeletonClass))
#define IS_DEVICE1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_DEVICE1_SKELETON))
#define IS_DEVICE1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_DEVICE1_SKELETON))

typedef struct _Device1Skeleton Device1Skeleton;
typedef struct _Device1SkeletonClass Device1SkeletonClass;
typedef struct _Device1SkeletonPrivate Device1SkeletonPrivate;

struct _Device1Skeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  Device1SkeletonPrivate *priv;
};

struct _Device1SkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType device1_skeleton_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (Device1Skeleton, g_object_unref)
#endif

Device1 *device1_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.bluez.GattService1 */

#define TYPE_GATT_SERVICE1 (gatt_service1_get_type ())
#define GATT_SERVICE1(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_GATT_SERVICE1, GattService1))
#define IS_GATT_SERVICE1(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_GATT_SERVICE1))
#define GATT_SERVICE1_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_GATT_SERVICE1, GattService1Iface))

struct _GattService1;
typedef struct _GattService1 GattService1;
typedef struct _GattService1Iface GattService1Iface;

struct _GattService1Iface
{
  GTypeInterface parent_iface;

  const gchar *const * (*get_characteristics) (GattService1 *object);

  const gchar * (*get_device) (GattService1 *object);

  gboolean  (*get_primary) (GattService1 *object);

  const gchar * (*get_uuid) (GattService1 *object);

};

GType gatt_service1_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *gatt_service1_interface_info (void);
guint gatt_service1_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus property accessors: */
const gchar *gatt_service1_get_uuid (GattService1 *object);
gchar *gatt_service1_dup_uuid (GattService1 *object);
void gatt_service1_set_uuid (GattService1 *object, const gchar *value);

const gchar *gatt_service1_get_device (GattService1 *object);
gchar *gatt_service1_dup_device (GattService1 *object);
void gatt_service1_set_device (GattService1 *object, const gchar *value);

gboolean gatt_service1_get_primary (GattService1 *object);
void gatt_service1_set_primary (GattService1 *object, gboolean value);

const gchar *const *gatt_service1_get_characteristics (GattService1 *object);
gchar **gatt_service1_dup_characteristics (GattService1 *object);
void gatt_service1_set_characteristics (GattService1 *object, const gchar *const *value);


/* ---- */

#define TYPE_GATT_SERVICE1_PROXY (gatt_service1_proxy_get_type ())
#define GATT_SERVICE1_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_GATT_SERVICE1_PROXY, GattService1Proxy))
#define GATT_SERVICE1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_GATT_SERVICE1_PROXY, GattService1ProxyClass))
#define GATT_SERVICE1_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_GATT_SERVICE1_PROXY, GattService1ProxyClass))
#define IS_GATT_SERVICE1_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_GATT_SERVICE1_PROXY))
#define IS_GATT_SERVICE1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_GATT_SERVICE1_PROXY))

typedef struct _GattService1Proxy GattService1Proxy;
typedef struct _GattService1ProxyClass GattService1ProxyClass;
typedef struct _GattService1ProxyPrivate GattService1ProxyPrivate;

struct _GattService1Proxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  GattService1ProxyPrivate *priv;
};

struct _GattService1ProxyClass
{
  GDBusProxyClass parent_class;
};

GType gatt_service1_proxy_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GattService1Proxy, g_object_unref)
#endif

void gatt_service1_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
GattService1 *gatt_service1_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
GattService1 *gatt_service1_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void gatt_service1_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
GattService1 *gatt_service1_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
GattService1 *gatt_service1_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define TYPE_GATT_SERVICE1_SKELETON (gatt_service1_skeleton_get_type ())
#define GATT_SERVICE1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_GATT_SERVICE1_SKELETON, GattService1Skeleton))
#define GATT_SERVICE1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_GATT_SERVICE1_SKELETON, GattService1SkeletonClass))
#define GATT_SERVICE1_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_GATT_SERVICE1_SKELETON, GattService1SkeletonClass))
#define IS_GATT_SERVICE1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_GATT_SERVICE1_SKELETON))
#define IS_GATT_SERVICE1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_GATT_SERVICE1_SKELETON))

typedef struct _GattService1Skeleton GattService1Skeleton;
typedef struct _GattService1SkeletonClass GattService1SkeletonClass;
typedef struct _GattService1SkeletonPrivate GattService1SkeletonPrivate;

struct _GattService1Skeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  GattService1SkeletonPrivate *priv;
};

struct _GattService1SkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType gatt_service1_skeleton_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GattService1Skeleton, g_object_unref)
#endif

GattService1 *gatt_service1_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.bluez.GattCharacteristic1 */

#define TYPE_GATT_CHARACTERISTIC1 (gatt_characteristic1_get_type ())
#define GATT_CHARACTERISTIC1(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_GATT_CHARACTERISTIC1, GattCharacteristic1))
#define IS_GATT_CHARACTERISTIC1(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_GATT_CHARACTERISTIC1))
#define GATT_CHARACTERISTIC1_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_GATT_CHARACTERISTIC1, GattCharacteristic1Iface))

struct _GattCharacteristic1;
typedef struct _GattCharacteristic1 GattCharacteristic1;
typedef struct _GattCharacteristic1Iface GattCharacteristic1Iface;

struct _GattCharacteristic1Iface
{
  GTypeInterface parent_iface;


  gboolean (*handle_read_value) (
    GattCharacteristic1 *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_options);

  gboolean (*handle_start_notify) (
    GattCharacteristic1 *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_stop_notify) (
    GattCharacteristic1 *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_write_value) (
    GattCharacteristic1 *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_value,
    GVariant *arg_options);

  const gchar *const * (*get_descriptors) (GattCharacteristic1 *object);

  const gchar *const * (*get_flags) (GattCharacteristic1 *object);

  gboolean  (*get_notifying) (GattCharacteristic1 *object);

  const gchar * (*get_service) (GattCharacteristic1 *object);

  const gchar * (*get_uuid) (GattCharacteristic1 *object);

  const gchar * (*get_value) (GattCharacteristic1 *object);

};

GType gatt_characteristic1_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *gatt_characteristic1_interface_info (void);
guint gatt_characteristic1_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void gatt_characteristic1_complete_read_value (
    GattCharacteristic1 *object,
    GDBusMethodInvocation *invocation,
    const gchar *value);

void gatt_characteristic1_complete_write_value (
    GattCharacteristic1 *object,
    GDBusMethodInvocation *invocation);

void gatt_characteristic1_complete_start_notify (
    GattCharacteristic1 *object,
    GDBusMethodInvocation *invocation);

void gatt_characteristic1_complete_stop_notify (
    GattCharacteristic1 *object,
    GDBusMethodInvocation *invocation);



/* D-Bus method calls: */
void gatt_characteristic1_call_read_value (
    GattCharacteristic1 *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean gatt_characteristic1_call_read_value_finish (
    GattCharacteristic1 *proxy,
    gchar **out_value,
    GAsyncResult *res,
    GError **error);

gboolean gatt_characteristic1_call_read_value_sync (
    GattCharacteristic1 *proxy,
    GVariant *arg_options,
    gchar **out_value,
    GCancellable *cancellable,
    GError **error);

void gatt_characteristic1_call_write_value (
    GattCharacteristic1 *proxy,
    const gchar *arg_value,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean gatt_characteristic1_call_write_value_finish (
    GattCharacteristic1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean gatt_characteristic1_call_write_value_sync (
    GattCharacteristic1 *proxy,
    const gchar *arg_value,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error);

void gatt_characteristic1_call_start_notify (
    GattCharacteristic1 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean gatt_characteristic1_call_start_notify_finish (
    GattCharacteristic1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean gatt_characteristic1_call_start_notify_sync (
    GattCharacteristic1 *proxy,
    GCancellable *cancellable,
    GError **error);

void gatt_characteristic1_call_stop_notify (
    GattCharacteristic1 *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean gatt_characteristic1_call_stop_notify_finish (
    GattCharacteristic1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean gatt_characteristic1_call_stop_notify_sync (
    GattCharacteristic1 *proxy,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
const gchar *gatt_characteristic1_get_uuid (GattCharacteristic1 *object);
gchar *gatt_characteristic1_dup_uuid (GattCharacteristic1 *object);
void gatt_characteristic1_set_uuid (GattCharacteristic1 *object, const gchar *value);

const gchar *gatt_characteristic1_get_service (GattCharacteristic1 *object);
gchar *gatt_characteristic1_dup_service (GattCharacteristic1 *object);
void gatt_characteristic1_set_service (GattCharacteristic1 *object, const gchar *value);

const gchar *gatt_characteristic1_get_value (GattCharacteristic1 *object);
gchar *gatt_characteristic1_dup_value (GattCharacteristic1 *object);
void gatt_characteristic1_set_value (GattCharacteristic1 *object, const gchar *value);

gboolean gatt_characteristic1_get_notifying (GattCharacteristic1 *object);
void gatt_characteristic1_set_notifying (GattCharacteristic1 *object, gboolean value);

const gchar *const *gatt_characteristic1_get_flags (GattCharacteristic1 *object);
gchar **gatt_characteristic1_dup_flags (GattCharacteristic1 *object);
void gatt_characteristic1_set_flags (GattCharacteristic1 *object, const gchar *const *value);

const gchar *const *gatt_characteristic1_get_descriptors (GattCharacteristic1 *object);
gchar **gatt_characteristic1_dup_descriptors (GattCharacteristic1 *object);
void gatt_characteristic1_set_descriptors (GattCharacteristic1 *object, const gchar *const *value);


/* ---- */

#define TYPE_GATT_CHARACTERISTIC1_PROXY (gatt_characteristic1_proxy_get_type ())
#define GATT_CHARACTERISTIC1_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_GATT_CHARACTERISTIC1_PROXY, GattCharacteristic1Proxy))
#define GATT_CHARACTERISTIC1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_GATT_CHARACTERISTIC1_PROXY, GattCharacteristic1ProxyClass))
#define GATT_CHARACTERISTIC1_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_GATT_CHARACTERISTIC1_PROXY, GattCharacteristic1ProxyClass))
#define IS_GATT_CHARACTERISTIC1_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_GATT_CHARACTERISTIC1_PROXY))
#define IS_GATT_CHARACTERISTIC1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_GATT_CHARACTERISTIC1_PROXY))

typedef struct _GattCharacteristic1Proxy GattCharacteristic1Proxy;
typedef struct _GattCharacteristic1ProxyClass GattCharacteristic1ProxyClass;
typedef struct _GattCharacteristic1ProxyPrivate GattCharacteristic1ProxyPrivate;

struct _GattCharacteristic1Proxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  GattCharacteristic1ProxyPrivate *priv;
};

struct _GattCharacteristic1ProxyClass
{
  GDBusProxyClass parent_class;
};

GType gatt_characteristic1_proxy_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GattCharacteristic1Proxy, g_object_unref)
#endif

void gatt_characteristic1_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
GattCharacteristic1 *gatt_characteristic1_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
GattCharacteristic1 *gatt_characteristic1_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void gatt_characteristic1_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
GattCharacteristic1 *gatt_characteristic1_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
GattCharacteristic1 *gatt_characteristic1_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define TYPE_GATT_CHARACTERISTIC1_SKELETON (gatt_characteristic1_skeleton_get_type ())
#define GATT_CHARACTERISTIC1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_GATT_CHARACTERISTIC1_SKELETON, GattCharacteristic1Skeleton))
#define GATT_CHARACTERISTIC1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_GATT_CHARACTERISTIC1_SKELETON, GattCharacteristic1SkeletonClass))
#define GATT_CHARACTERISTIC1_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_GATT_CHARACTERISTIC1_SKELETON, GattCharacteristic1SkeletonClass))
#define IS_GATT_CHARACTERISTIC1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_GATT_CHARACTERISTIC1_SKELETON))
#define IS_GATT_CHARACTERISTIC1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_GATT_CHARACTERISTIC1_SKELETON))

typedef struct _GattCharacteristic1Skeleton GattCharacteristic1Skeleton;
typedef struct _GattCharacteristic1SkeletonClass GattCharacteristic1SkeletonClass;
typedef struct _GattCharacteristic1SkeletonPrivate GattCharacteristic1SkeletonPrivate;

struct _GattCharacteristic1Skeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  GattCharacteristic1SkeletonPrivate *priv;
};

struct _GattCharacteristic1SkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType gatt_characteristic1_skeleton_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GattCharacteristic1Skeleton, g_object_unref)
#endif

GattCharacteristic1 *gatt_characteristic1_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.bluez.GattDescriptor1 */

#define TYPE_GATT_DESCRIPTOR1 (gatt_descriptor1_get_type ())
#define GATT_DESCRIPTOR1(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_GATT_DESCRIPTOR1, GattDescriptor1))
#define IS_GATT_DESCRIPTOR1(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_GATT_DESCRIPTOR1))
#define GATT_DESCRIPTOR1_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_GATT_DESCRIPTOR1, GattDescriptor1Iface))

struct _GattDescriptor1;
typedef struct _GattDescriptor1 GattDescriptor1;
typedef struct _GattDescriptor1Iface GattDescriptor1Iface;

struct _GattDescriptor1Iface
{
  GTypeInterface parent_iface;


  gboolean (*handle_read_value) (
    GattDescriptor1 *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_options);

  gboolean (*handle_write_value) (
    GattDescriptor1 *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_value,
    GVariant *arg_options);

  const gchar * (*get_characteristic) (GattDescriptor1 *object);

  const gchar * (*get_uuid) (GattDescriptor1 *object);

  const gchar * (*get_value) (GattDescriptor1 *object);

};

GType gatt_descriptor1_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *gatt_descriptor1_interface_info (void);
guint gatt_descriptor1_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void gatt_descriptor1_complete_read_value (
    GattDescriptor1 *object,
    GDBusMethodInvocation *invocation,
    const gchar *value);

void gatt_descriptor1_complete_write_value (
    GattDescriptor1 *object,
    GDBusMethodInvocation *invocation);



/* D-Bus method calls: */
void gatt_descriptor1_call_read_value (
    GattDescriptor1 *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean gatt_descriptor1_call_read_value_finish (
    GattDescriptor1 *proxy,
    gchar **out_value,
    GAsyncResult *res,
    GError **error);

gboolean gatt_descriptor1_call_read_value_sync (
    GattDescriptor1 *proxy,
    GVariant *arg_options,
    gchar **out_value,
    GCancellable *cancellable,
    GError **error);

void gatt_descriptor1_call_write_value (
    GattDescriptor1 *proxy,
    const gchar *arg_value,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean gatt_descriptor1_call_write_value_finish (
    GattDescriptor1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean gatt_descriptor1_call_write_value_sync (
    GattDescriptor1 *proxy,
    const gchar *arg_value,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
const gchar *gatt_descriptor1_get_uuid (GattDescriptor1 *object);
gchar *gatt_descriptor1_dup_uuid (GattDescriptor1 *object);
void gatt_descriptor1_set_uuid (GattDescriptor1 *object, const gchar *value);

const gchar *gatt_descriptor1_get_characteristic (GattDescriptor1 *object);
gchar *gatt_descriptor1_dup_characteristic (GattDescriptor1 *object);
void gatt_descriptor1_set_characteristic (GattDescriptor1 *object, const gchar *value);

const gchar *gatt_descriptor1_get_value (GattDescriptor1 *object);
gchar *gatt_descriptor1_dup_value (GattDescriptor1 *object);
void gatt_descriptor1_set_value (GattDescriptor1 *object, const gchar *value);


/* ---- */

#define TYPE_GATT_DESCRIPTOR1_PROXY (gatt_descriptor1_proxy_get_type ())
#define GATT_DESCRIPTOR1_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_GATT_DESCRIPTOR1_PROXY, GattDescriptor1Proxy))
#define GATT_DESCRIPTOR1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_GATT_DESCRIPTOR1_PROXY, GattDescriptor1ProxyClass))
#define GATT_DESCRIPTOR1_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_GATT_DESCRIPTOR1_PROXY, GattDescriptor1ProxyClass))
#define IS_GATT_DESCRIPTOR1_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_GATT_DESCRIPTOR1_PROXY))
#define IS_GATT_DESCRIPTOR1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_GATT_DESCRIPTOR1_PROXY))

typedef struct _GattDescriptor1Proxy GattDescriptor1Proxy;
typedef struct _GattDescriptor1ProxyClass GattDescriptor1ProxyClass;
typedef struct _GattDescriptor1ProxyPrivate GattDescriptor1ProxyPrivate;

struct _GattDescriptor1Proxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  GattDescriptor1ProxyPrivate *priv;
};

struct _GattDescriptor1ProxyClass
{
  GDBusProxyClass parent_class;
};

GType gatt_descriptor1_proxy_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GattDescriptor1Proxy, g_object_unref)
#endif

void gatt_descriptor1_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
GattDescriptor1 *gatt_descriptor1_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
GattDescriptor1 *gatt_descriptor1_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void gatt_descriptor1_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
GattDescriptor1 *gatt_descriptor1_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
GattDescriptor1 *gatt_descriptor1_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define TYPE_GATT_DESCRIPTOR1_SKELETON (gatt_descriptor1_skeleton_get_type ())
#define GATT_DESCRIPTOR1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_GATT_DESCRIPTOR1_SKELETON, GattDescriptor1Skeleton))
#define GATT_DESCRIPTOR1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_GATT_DESCRIPTOR1_SKELETON, GattDescriptor1SkeletonClass))
#define GATT_DESCRIPTOR1_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_GATT_DESCRIPTOR1_SKELETON, GattDescriptor1SkeletonClass))
#define IS_GATT_DESCRIPTOR1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_GATT_DESCRIPTOR1_SKELETON))
#define IS_GATT_DESCRIPTOR1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_GATT_DESCRIPTOR1_SKELETON))

typedef struct _GattDescriptor1Skeleton GattDescriptor1Skeleton;
typedef struct _GattDescriptor1SkeletonClass GattDescriptor1SkeletonClass;
typedef struct _GattDescriptor1SkeletonPrivate GattDescriptor1SkeletonPrivate;

struct _GattDescriptor1Skeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  GattDescriptor1SkeletonPrivate *priv;
};

struct _GattDescriptor1SkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType gatt_descriptor1_skeleton_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (GattDescriptor1Skeleton, g_object_unref)
#endif

GattDescriptor1 *gatt_descriptor1_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.bluez.LEAdvertisement1 */

#define TYPE_LEADVERTISEMENT1 (leadvertisement1_get_type ())
#define LEADVERTISEMENT1(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_LEADVERTISEMENT1, LEAdvertisement1))
#define IS_LEADVERTISEMENT1(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_LEADVERTISEMENT1))
#define LEADVERTISEMENT1_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_LEADVERTISEMENT1, LEAdvertisement1Iface))

struct _LEAdvertisement1;
typedef struct _LEAdvertisement1 LEAdvertisement1;
typedef struct _LEAdvertisement1Iface LEAdvertisement1Iface;

struct _LEAdvertisement1Iface
{
  GTypeInterface parent_iface;


  gboolean (*handle_release) (
    LEAdvertisement1 *object,
    GDBusMethodInvocation *invocation);

  gboolean  (*get_include_tx_power) (LEAdvertisement1 *object);

  GVariant * (*get_manufacturer_data) (LEAdvertisement1 *object);

  GVariant * (*get_service_data) (LEAdvertisement1 *object);

  const gchar *const * (*get_service_uuids) (LEAdvertisement1 *object);

  const gchar *const * (*get_solicit_uuids) (LEAdvertisement1 *object);

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

};

GType leadvertisement1_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *leadvertisement1_interface_info (void);
guint leadvertisement1_override_properties (GObjectClass *klass, guint property_id_begin);


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



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

gboolean leadvertisement1_call_release_finish (
    LEAdvertisement1 *proxy,
    GAsyncResult *res,
    GError **error);

gboolean leadvertisement1_call_release_sync (
    LEAdvertisement1 *proxy,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
const gchar *leadvertisement1_get_type_ (LEAdvertisement1 *object);
gchar *leadvertisement1_dup_type_ (LEAdvertisement1 *object);
void leadvertisement1_set_type_ (LEAdvertisement1 *object, const gchar *value);

const gchar *const *leadvertisement1_get_service_uuids (LEAdvertisement1 *object);
gchar **leadvertisement1_dup_service_uuids (LEAdvertisement1 *object);
void leadvertisement1_set_service_uuids (LEAdvertisement1 *object, const gchar *const *value);

GVariant *leadvertisement1_get_manufacturer_data (LEAdvertisement1 *object);
GVariant *leadvertisement1_dup_manufacturer_data (LEAdvertisement1 *object);
void leadvertisement1_set_manufacturer_data (LEAdvertisement1 *object, GVariant *value);

const gchar *const *leadvertisement1_get_solicit_uuids (LEAdvertisement1 *object);
gchar **leadvertisement1_dup_solicit_uuids (LEAdvertisement1 *object);
void leadvertisement1_set_solicit_uuids (LEAdvertisement1 *object, const gchar *const *value);

GVariant *leadvertisement1_get_service_data (LEAdvertisement1 *object);
GVariant *leadvertisement1_dup_service_data (LEAdvertisement1 *object);
void leadvertisement1_set_service_data (LEAdvertisement1 *object, GVariant *value);

gboolean leadvertisement1_get_include_tx_power (LEAdvertisement1 *object);
void leadvertisement1_set_include_tx_power (LEAdvertisement1 *object, gboolean value);


/* ---- */

#define TYPE_LEADVERTISEMENT1_PROXY (leadvertisement1_proxy_get_type ())
#define LEADVERTISEMENT1_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_LEADVERTISEMENT1_PROXY, LEAdvertisement1Proxy))
#define LEADVERTISEMENT1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_LEADVERTISEMENT1_PROXY, LEAdvertisement1ProxyClass))
#define LEADVERTISEMENT1_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_LEADVERTISEMENT1_PROXY, LEAdvertisement1ProxyClass))
#define IS_LEADVERTISEMENT1_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_LEADVERTISEMENT1_PROXY))
#define IS_LEADVERTISEMENT1_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_LEADVERTISEMENT1_PROXY))

typedef struct _LEAdvertisement1Proxy LEAdvertisement1Proxy;
typedef struct _LEAdvertisement1ProxyClass LEAdvertisement1ProxyClass;
typedef struct _LEAdvertisement1ProxyPrivate LEAdvertisement1ProxyPrivate;

struct _LEAdvertisement1Proxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  LEAdvertisement1ProxyPrivate *priv;
};

struct _LEAdvertisement1ProxyClass
{
  GDBusProxyClass parent_class;
};

GType leadvertisement1_proxy_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (LEAdvertisement1Proxy, g_object_unref)
#endif

void leadvertisement1_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
LEAdvertisement1 *leadvertisement1_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
LEAdvertisement1 *leadvertisement1_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void leadvertisement1_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
LEAdvertisement1 *leadvertisement1_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
LEAdvertisement1 *leadvertisement1_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define TYPE_LEADVERTISEMENT1_SKELETON (leadvertisement1_skeleton_get_type ())
#define LEADVERTISEMENT1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_LEADVERTISEMENT1_SKELETON, LEAdvertisement1Skeleton))
#define LEADVERTISEMENT1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_LEADVERTISEMENT1_SKELETON, LEAdvertisement1SkeletonClass))
#define LEADVERTISEMENT1_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_LEADVERTISEMENT1_SKELETON, LEAdvertisement1SkeletonClass))
#define IS_LEADVERTISEMENT1_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_LEADVERTISEMENT1_SKELETON))
#define IS_LEADVERTISEMENT1_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_LEADVERTISEMENT1_SKELETON))

typedef struct _LEAdvertisement1Skeleton LEAdvertisement1Skeleton;
typedef struct _LEAdvertisement1SkeletonClass LEAdvertisement1SkeletonClass;
typedef struct _LEAdvertisement1SkeletonPrivate LEAdvertisement1SkeletonPrivate;

struct _LEAdvertisement1Skeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  LEAdvertisement1SkeletonPrivate *priv;
};

struct _LEAdvertisement1SkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType leadvertisement1_skeleton_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (LEAdvertisement1Skeleton, g_object_unref)
#endif

LEAdvertisement1 *leadvertisement1_skeleton_new (void);


/* ---- */

#define TYPE_OBJECT (object_get_type ())
#define OBJECT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_OBJECT, Object))
#define IS_OBJECT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_OBJECT))
#define OBJECT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), TYPE_OBJECT, Object))

struct _Object;
typedef struct _Object Object;
typedef struct _ObjectIface ObjectIface;

struct _ObjectIface
{
  GTypeInterface parent_iface;
};

GType object_get_type (void) G_GNUC_CONST;

Adapter1 *object_get_adapter1 (Object *object);
Device1 *object_get_device1 (Object *object);
GattService1 *object_get_gatt_service1 (Object *object);
GattCharacteristic1 *object_get_gatt_characteristic1 (Object *object);
GattDescriptor1 *object_get_gatt_descriptor1 (Object *object);
LEAdvertisement1 *object_get_leadvertisement1 (Object *object);
Adapter1 *object_peek_adapter1 (Object *object);
Device1 *object_peek_device1 (Object *object);
GattService1 *object_peek_gatt_service1 (Object *object);
GattCharacteristic1 *object_peek_gatt_characteristic1 (Object *object);
GattDescriptor1 *object_peek_gatt_descriptor1 (Object *object);
LEAdvertisement1 *object_peek_leadvertisement1 (Object *object);

#define TYPE_OBJECT_PROXY (object_proxy_get_type ())
#define OBJECT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_OBJECT_PROXY, ObjectProxy))
#define OBJECT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_OBJECT_PROXY, ObjectProxyClass))
#define OBJECT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_OBJECT_PROXY, ObjectProxyClass))
#define IS_OBJECT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_OBJECT_PROXY))
#define IS_OBJECT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_OBJECT_PROXY))

typedef struct _ObjectProxy ObjectProxy;
typedef struct _ObjectProxyClass ObjectProxyClass;
typedef struct _ObjectProxyPrivate ObjectProxyPrivate;

struct _ObjectProxy
{
  /*< private >*/
  GDBusObjectProxy parent_instance;
  ObjectProxyPrivate *priv;
};

struct _ObjectProxyClass
{
  GDBusObjectProxyClass parent_class;
};

GType object_proxy_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (ObjectProxy, g_object_unref)
#endif

ObjectProxy *object_proxy_new (GDBusConnection *connection, const gchar *object_path);

#define TYPE_OBJECT_SKELETON (object_skeleton_get_type ())
#define OBJECT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_OBJECT_SKELETON, ObjectSkeleton))
#define OBJECT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_OBJECT_SKELETON, ObjectSkeletonClass))
#define OBJECT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_OBJECT_SKELETON, ObjectSkeletonClass))
#define IS_OBJECT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_OBJECT_SKELETON))
#define IS_OBJECT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_OBJECT_SKELETON))

typedef struct _ObjectSkeleton ObjectSkeleton;
typedef struct _ObjectSkeletonClass ObjectSkeletonClass;
typedef struct _ObjectSkeletonPrivate ObjectSkeletonPrivate;

struct _ObjectSkeleton
{
  /*< private >*/
  GDBusObjectSkeleton parent_instance;
  ObjectSkeletonPrivate *priv;
};

struct _ObjectSkeletonClass
{
  GDBusObjectSkeletonClass parent_class;
};

GType object_skeleton_get_type (void) G_GNUC_CONST;

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (ObjectSkeleton, g_object_unref)
#endif

ObjectSkeleton *object_skeleton_new (const gchar *object_path);
void object_skeleton_set_adapter1 (ObjectSkeleton *object, Adapter1 *interface_);
void object_skeleton_set_device1 (ObjectSkeleton *object, Device1 *interface_);
void object_skeleton_set_gatt_service1 (ObjectSkeleton *object, GattService1 *interface_);
void object_skeleton_set_gatt_characteristic1 (ObjectSkeleton *object, GattCharacteristic1 *interface_);
void object_skeleton_set_gatt_descriptor1 (ObjectSkeleton *object, GattDescriptor1 *interface_);
void object_skeleton_set_leadvertisement1 (ObjectSkeleton *object, LEAdvertisement1 *interface_);

/* ---- */

#define TYPE_OBJECT_MANAGER_CLIENT (object_manager_client_get_type ())
#define OBJECT_MANAGER_CLIENT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), TYPE_OBJECT_MANAGER_CLIENT, ObjectManagerClient))
#define OBJECT_MANAGER_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), TYPE_OBJECT_MANAGER_CLIENT, ObjectManagerClientClass))
#define OBJECT_MANAGER_CLIENT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), TYPE_OBJECT_MANAGER_CLIENT, ObjectManagerClientClass))
#define IS_OBJECT_MANAGER_CLIENT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), TYPE_OBJECT_MANAGER_CLIENT))
#define IS_OBJECT_MANAGER_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), TYPE_OBJECT_MANAGER_CLIENT))

typedef struct _ObjectManagerClient ObjectManagerClient;
typedef struct _ObjectManagerClientClass ObjectManagerClientClass;
typedef struct _ObjectManagerClientPrivate ObjectManagerClientPrivate;

struct _ObjectManagerClient
{
  /*< private >*/
  GDBusObjectManagerClient parent_instance;
  ObjectManagerClientPrivate *priv;
};

struct _ObjectManagerClientClass
{
  GDBusObjectManagerClientClass parent_class;
};

#if GLIB_CHECK_VERSION(2, 44, 0)
G_DEFINE_AUTOPTR_CLEANUP_FUNC (ObjectManagerClient, g_object_unref)
#endif

GType object_manager_client_get_type (void) G_GNUC_CONST;

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

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

void 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 *object_manager_client_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
GDBusObjectManager *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 /* __GENERATED_CODE_H__ */