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

#ifndef __MM_GDBUS_MODEM_H__
#define __MM_GDBUS_MODEM_H__

#include <gio/gio.h>

G_BEGIN_DECLS


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.ModemManager1.Modem */

#define MM_GDBUS_TYPE_MODEM (mm_gdbus_modem_get_type ())
#define MM_GDBUS_MODEM(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM, MmGdbusModem))
#define MM_GDBUS_IS_MODEM(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM))
#define MM_GDBUS_MODEM_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), MM_GDBUS_TYPE_MODEM, MmGdbusModemIface))

struct _MmGdbusModem;
typedef struct _MmGdbusModem MmGdbusModem;
typedef struct _MmGdbusModemIface MmGdbusModemIface;

struct _MmGdbusModemIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_command) (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_cmd,
    guint arg_timeout);

  gboolean (*handle_create_bearer) (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_properties);

  gboolean (*handle_delete_bearer) (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_bearer);

  gboolean (*handle_enable) (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation,
    gboolean arg_enable);

  gboolean (*handle_factory_reset) (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_code);

  gboolean (*handle_list_bearers) (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_reset) (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_set_current_bands) (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_bands);

  gboolean (*handle_set_current_capabilities) (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation,
    guint arg_capabilities);

  gboolean (*handle_set_current_modes) (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_modes);

  gboolean (*handle_set_power_state) (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation,
    guint arg_state);

  guint  (*get_access_technologies) (MmGdbusModem *object);

  const gchar *const * (*get_bearers) (MmGdbusModem *object);

  GVariant * (*get_current_bands) (MmGdbusModem *object);

  guint  (*get_current_capabilities) (MmGdbusModem *object);

  GVariant * (*get_current_modes) (MmGdbusModem *object);

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

  const gchar * (*get_device_identifier) (MmGdbusModem *object);

  const gchar *const * (*get_drivers) (MmGdbusModem *object);

  const gchar * (*get_equipment_identifier) (MmGdbusModem *object);

  const gchar * (*get_manufacturer) (MmGdbusModem *object);

  guint  (*get_max_active_bearers) (MmGdbusModem *object);

  guint  (*get_max_bearers) (MmGdbusModem *object);

  const gchar * (*get_model) (MmGdbusModem *object);

  const gchar *const * (*get_own_numbers) (MmGdbusModem *object);

  const gchar * (*get_plugin) (MmGdbusModem *object);

  GVariant * (*get_ports) (MmGdbusModem *object);

  guint  (*get_power_state) (MmGdbusModem *object);

  const gchar * (*get_primary_port) (MmGdbusModem *object);

  const gchar * (*get_revision) (MmGdbusModem *object);

  GVariant * (*get_signal_quality) (MmGdbusModem *object);

  const gchar * (*get_sim) (MmGdbusModem *object);

  gint  (*get_state) (MmGdbusModem *object);

  guint  (*get_state_failed_reason) (MmGdbusModem *object);

  GVariant * (*get_supported_bands) (MmGdbusModem *object);

  GVariant * (*get_supported_capabilities) (MmGdbusModem *object);

  guint  (*get_supported_ip_families) (MmGdbusModem *object);

  GVariant * (*get_supported_modes) (MmGdbusModem *object);

  guint  (*get_unlock_required) (MmGdbusModem *object);

  GVariant * (*get_unlock_retries) (MmGdbusModem *object);

  void (*state_changed) (
    MmGdbusModem *object,
    gint arg_old,
    gint arg_new,
    guint arg_reason);

};

GType mm_gdbus_modem_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *mm_gdbus_modem_interface_info (void);
guint mm_gdbus_modem_override_properties (GObjectClass *klass, guint property_id_begin);


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

void mm_gdbus_modem_complete_list_bearers (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *bearers);

void mm_gdbus_modem_complete_create_bearer (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation,
    const gchar *path);

void mm_gdbus_modem_complete_delete_bearer (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation);

void mm_gdbus_modem_complete_reset (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation);

void mm_gdbus_modem_complete_factory_reset (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation);

void mm_gdbus_modem_complete_set_power_state (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation);

void mm_gdbus_modem_complete_set_current_capabilities (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation);

void mm_gdbus_modem_complete_set_current_modes (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation);

void mm_gdbus_modem_complete_set_current_bands (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation);

void mm_gdbus_modem_complete_command (
    MmGdbusModem *object,
    GDBusMethodInvocation *invocation,
    const gchar *response);



/* D-Bus signal emissions functions: */
void mm_gdbus_modem_emit_state_changed (
    MmGdbusModem *object,
    gint arg_old,
    gint arg_new,
    guint arg_reason);



/* D-Bus method calls: */
void mm_gdbus_modem_call_enable (
    MmGdbusModem *proxy,
    gboolean arg_enable,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_call_enable_finish (
    MmGdbusModem *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_call_enable_sync (
    MmGdbusModem *proxy,
    gboolean arg_enable,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_call_list_bearers (
    MmGdbusModem *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_call_list_bearers_finish (
    MmGdbusModem *proxy,
    gchar ***out_bearers,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_call_list_bearers_sync (
    MmGdbusModem *proxy,
    gchar ***out_bearers,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_call_create_bearer (
    MmGdbusModem *proxy,
    GVariant *arg_properties,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_call_create_bearer_finish (
    MmGdbusModem *proxy,
    gchar **out_path,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_call_create_bearer_sync (
    MmGdbusModem *proxy,
    GVariant *arg_properties,
    gchar **out_path,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_call_delete_bearer (
    MmGdbusModem *proxy,
    const gchar *arg_bearer,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_call_delete_bearer_finish (
    MmGdbusModem *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_call_delete_bearer_sync (
    MmGdbusModem *proxy,
    const gchar *arg_bearer,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_call_reset (
    MmGdbusModem *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_call_reset_finish (
    MmGdbusModem *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_call_reset_sync (
    MmGdbusModem *proxy,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_call_factory_reset (
    MmGdbusModem *proxy,
    const gchar *arg_code,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_call_factory_reset_finish (
    MmGdbusModem *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_call_factory_reset_sync (
    MmGdbusModem *proxy,
    const gchar *arg_code,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_call_set_power_state (
    MmGdbusModem *proxy,
    guint arg_state,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_call_set_power_state_finish (
    MmGdbusModem *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_call_set_power_state_sync (
    MmGdbusModem *proxy,
    guint arg_state,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_call_set_current_capabilities (
    MmGdbusModem *proxy,
    guint arg_capabilities,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_call_set_current_capabilities_finish (
    MmGdbusModem *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_call_set_current_capabilities_sync (
    MmGdbusModem *proxy,
    guint arg_capabilities,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_call_set_current_modes (
    MmGdbusModem *proxy,
    GVariant *arg_modes,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_call_set_current_modes_finish (
    MmGdbusModem *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_call_set_current_modes_sync (
    MmGdbusModem *proxy,
    GVariant *arg_modes,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_call_set_current_bands (
    MmGdbusModem *proxy,
    GVariant *arg_bands,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_call_set_current_bands_finish (
    MmGdbusModem *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_call_set_current_bands_sync (
    MmGdbusModem *proxy,
    GVariant *arg_bands,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_call_command (
    MmGdbusModem *proxy,
    const gchar *arg_cmd,
    guint arg_timeout,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_call_command_finish (
    MmGdbusModem *proxy,
    gchar **out_response,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_call_command_sync (
    MmGdbusModem *proxy,
    const gchar *arg_cmd,
    guint arg_timeout,
    gchar **out_response,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
const gchar *mm_gdbus_modem_get_sim (MmGdbusModem *object);
gchar *mm_gdbus_modem_dup_sim (MmGdbusModem *object);
void mm_gdbus_modem_set_sim (MmGdbusModem *object, const gchar *value);

const gchar *const *mm_gdbus_modem_get_bearers (MmGdbusModem *object);
gchar **mm_gdbus_modem_dup_bearers (MmGdbusModem *object);
void mm_gdbus_modem_set_bearers (MmGdbusModem *object, const gchar *const *value);

GVariant *mm_gdbus_modem_get_supported_capabilities (MmGdbusModem *object);
GVariant *mm_gdbus_modem_dup_supported_capabilities (MmGdbusModem *object);
void mm_gdbus_modem_set_supported_capabilities (MmGdbusModem *object, GVariant *value);

guint mm_gdbus_modem_get_current_capabilities (MmGdbusModem *object);
void mm_gdbus_modem_set_current_capabilities (MmGdbusModem *object, guint value);

guint mm_gdbus_modem_get_max_bearers (MmGdbusModem *object);
void mm_gdbus_modem_set_max_bearers (MmGdbusModem *object, guint value);

guint mm_gdbus_modem_get_max_active_bearers (MmGdbusModem *object);
void mm_gdbus_modem_set_max_active_bearers (MmGdbusModem *object, guint value);

const gchar *mm_gdbus_modem_get_manufacturer (MmGdbusModem *object);
gchar *mm_gdbus_modem_dup_manufacturer (MmGdbusModem *object);
void mm_gdbus_modem_set_manufacturer (MmGdbusModem *object, const gchar *value);

const gchar *mm_gdbus_modem_get_model (MmGdbusModem *object);
gchar *mm_gdbus_modem_dup_model (MmGdbusModem *object);
void mm_gdbus_modem_set_model (MmGdbusModem *object, const gchar *value);

const gchar *mm_gdbus_modem_get_revision (MmGdbusModem *object);
gchar *mm_gdbus_modem_dup_revision (MmGdbusModem *object);
void mm_gdbus_modem_set_revision (MmGdbusModem *object, const gchar *value);

const gchar *mm_gdbus_modem_get_device_identifier (MmGdbusModem *object);
gchar *mm_gdbus_modem_dup_device_identifier (MmGdbusModem *object);
void mm_gdbus_modem_set_device_identifier (MmGdbusModem *object, const gchar *value);

const gchar *mm_gdbus_modem_get_device (MmGdbusModem *object);
gchar *mm_gdbus_modem_dup_device (MmGdbusModem *object);
void mm_gdbus_modem_set_device (MmGdbusModem *object, const gchar *value);

const gchar *const *mm_gdbus_modem_get_drivers (MmGdbusModem *object);
gchar **mm_gdbus_modem_dup_drivers (MmGdbusModem *object);
void mm_gdbus_modem_set_drivers (MmGdbusModem *object, const gchar *const *value);

const gchar *mm_gdbus_modem_get_plugin (MmGdbusModem *object);
gchar *mm_gdbus_modem_dup_plugin (MmGdbusModem *object);
void mm_gdbus_modem_set_plugin (MmGdbusModem *object, const gchar *value);

const gchar *mm_gdbus_modem_get_primary_port (MmGdbusModem *object);
gchar *mm_gdbus_modem_dup_primary_port (MmGdbusModem *object);
void mm_gdbus_modem_set_primary_port (MmGdbusModem *object, const gchar *value);

GVariant *mm_gdbus_modem_get_ports (MmGdbusModem *object);
GVariant *mm_gdbus_modem_dup_ports (MmGdbusModem *object);
void mm_gdbus_modem_set_ports (MmGdbusModem *object, GVariant *value);

const gchar *mm_gdbus_modem_get_equipment_identifier (MmGdbusModem *object);
gchar *mm_gdbus_modem_dup_equipment_identifier (MmGdbusModem *object);
void mm_gdbus_modem_set_equipment_identifier (MmGdbusModem *object, const gchar *value);

guint mm_gdbus_modem_get_unlock_required (MmGdbusModem *object);
void mm_gdbus_modem_set_unlock_required (MmGdbusModem *object, guint value);

GVariant *mm_gdbus_modem_get_unlock_retries (MmGdbusModem *object);
GVariant *mm_gdbus_modem_dup_unlock_retries (MmGdbusModem *object);
void mm_gdbus_modem_set_unlock_retries (MmGdbusModem *object, GVariant *value);

gint mm_gdbus_modem_get_state (MmGdbusModem *object);
void mm_gdbus_modem_set_state (MmGdbusModem *object, gint value);

guint mm_gdbus_modem_get_state_failed_reason (MmGdbusModem *object);
void mm_gdbus_modem_set_state_failed_reason (MmGdbusModem *object, guint value);

guint mm_gdbus_modem_get_access_technologies (MmGdbusModem *object);
void mm_gdbus_modem_set_access_technologies (MmGdbusModem *object, guint value);

GVariant *mm_gdbus_modem_get_signal_quality (MmGdbusModem *object);
GVariant *mm_gdbus_modem_dup_signal_quality (MmGdbusModem *object);
void mm_gdbus_modem_set_signal_quality (MmGdbusModem *object, GVariant *value);

const gchar *const *mm_gdbus_modem_get_own_numbers (MmGdbusModem *object);
gchar **mm_gdbus_modem_dup_own_numbers (MmGdbusModem *object);
void mm_gdbus_modem_set_own_numbers (MmGdbusModem *object, const gchar *const *value);

guint mm_gdbus_modem_get_power_state (MmGdbusModem *object);
void mm_gdbus_modem_set_power_state (MmGdbusModem *object, guint value);

GVariant *mm_gdbus_modem_get_supported_modes (MmGdbusModem *object);
GVariant *mm_gdbus_modem_dup_supported_modes (MmGdbusModem *object);
void mm_gdbus_modem_set_supported_modes (MmGdbusModem *object, GVariant *value);

GVariant *mm_gdbus_modem_get_current_modes (MmGdbusModem *object);
GVariant *mm_gdbus_modem_dup_current_modes (MmGdbusModem *object);
void mm_gdbus_modem_set_current_modes (MmGdbusModem *object, GVariant *value);

GVariant *mm_gdbus_modem_get_supported_bands (MmGdbusModem *object);
GVariant *mm_gdbus_modem_dup_supported_bands (MmGdbusModem *object);
void mm_gdbus_modem_set_supported_bands (MmGdbusModem *object, GVariant *value);

GVariant *mm_gdbus_modem_get_current_bands (MmGdbusModem *object);
GVariant *mm_gdbus_modem_dup_current_bands (MmGdbusModem *object);
void mm_gdbus_modem_set_current_bands (MmGdbusModem *object, GVariant *value);

guint mm_gdbus_modem_get_supported_ip_families (MmGdbusModem *object);
void mm_gdbus_modem_set_supported_ip_families (MmGdbusModem *object, guint value);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_PROXY (mm_gdbus_modem_proxy_get_type ())
#define MM_GDBUS_MODEM_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_PROXY, MmGdbusModemProxy))
#define MM_GDBUS_MODEM_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_PROXY, MmGdbusModemProxyClass))
#define MM_GDBUS_MODEM_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_PROXY, MmGdbusModemProxyClass))
#define MM_GDBUS_IS_MODEM_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_PROXY))
#define MM_GDBUS_IS_MODEM_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_PROXY))

typedef struct _MmGdbusModemProxy MmGdbusModemProxy;
typedef struct _MmGdbusModemProxyClass MmGdbusModemProxyClass;
typedef struct _MmGdbusModemProxyPrivate MmGdbusModemProxyPrivate;

struct _MmGdbusModemProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  MmGdbusModemProxyPrivate *priv;
};

struct _MmGdbusModemProxyClass
{
  GDBusProxyClass parent_class;
};

GType mm_gdbus_modem_proxy_get_type (void) G_GNUC_CONST;

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

void mm_gdbus_modem_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModem *mm_gdbus_modem_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModem *mm_gdbus_modem_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void mm_gdbus_modem_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModem *mm_gdbus_modem_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModem *mm_gdbus_modem_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_SKELETON (mm_gdbus_modem_skeleton_get_type ())
#define MM_GDBUS_MODEM_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_SKELETON, MmGdbusModemSkeleton))
#define MM_GDBUS_MODEM_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_SKELETON, MmGdbusModemSkeletonClass))
#define MM_GDBUS_MODEM_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_SKELETON, MmGdbusModemSkeletonClass))
#define MM_GDBUS_IS_MODEM_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_SKELETON))
#define MM_GDBUS_IS_MODEM_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_SKELETON))

typedef struct _MmGdbusModemSkeleton MmGdbusModemSkeleton;
typedef struct _MmGdbusModemSkeletonClass MmGdbusModemSkeletonClass;
typedef struct _MmGdbusModemSkeletonPrivate MmGdbusModemSkeletonPrivate;

struct _MmGdbusModemSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  MmGdbusModemSkeletonPrivate *priv;
};

struct _MmGdbusModemSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType mm_gdbus_modem_skeleton_get_type (void) G_GNUC_CONST;

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

MmGdbusModem *mm_gdbus_modem_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.ModemManager1.Modem.Messaging */

#define MM_GDBUS_TYPE_MODEM_MESSAGING (mm_gdbus_modem_messaging_get_type ())
#define MM_GDBUS_MODEM_MESSAGING(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_MESSAGING, MmGdbusModemMessaging))
#define MM_GDBUS_IS_MODEM_MESSAGING(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_MESSAGING))
#define MM_GDBUS_MODEM_MESSAGING_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), MM_GDBUS_TYPE_MODEM_MESSAGING, MmGdbusModemMessagingIface))

struct _MmGdbusModemMessaging;
typedef struct _MmGdbusModemMessaging MmGdbusModemMessaging;
typedef struct _MmGdbusModemMessagingIface MmGdbusModemMessagingIface;

struct _MmGdbusModemMessagingIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_create) (
    MmGdbusModemMessaging *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_properties);

  gboolean (*handle_delete) (
    MmGdbusModemMessaging *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_path);

  gboolean (*handle_list) (
    MmGdbusModemMessaging *object,
    GDBusMethodInvocation *invocation);

  guint  (*get_default_storage) (MmGdbusModemMessaging *object);

  const gchar *const * (*get_messages) (MmGdbusModemMessaging *object);

  GVariant * (*get_supported_storages) (MmGdbusModemMessaging *object);

  void (*added) (
    MmGdbusModemMessaging *object,
    const gchar *arg_path,
    gboolean arg_received);

  void (*deleted) (
    MmGdbusModemMessaging *object,
    const gchar *arg_path);

};

GType mm_gdbus_modem_messaging_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *mm_gdbus_modem_messaging_interface_info (void);
guint mm_gdbus_modem_messaging_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void mm_gdbus_modem_messaging_complete_list (
    MmGdbusModemMessaging *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *result);

void mm_gdbus_modem_messaging_complete_delete (
    MmGdbusModemMessaging *object,
    GDBusMethodInvocation *invocation);

void mm_gdbus_modem_messaging_complete_create (
    MmGdbusModemMessaging *object,
    GDBusMethodInvocation *invocation,
    const gchar *path);



/* D-Bus signal emissions functions: */
void mm_gdbus_modem_messaging_emit_added (
    MmGdbusModemMessaging *object,
    const gchar *arg_path,
    gboolean arg_received);

void mm_gdbus_modem_messaging_emit_deleted (
    MmGdbusModemMessaging *object,
    const gchar *arg_path);



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

gboolean mm_gdbus_modem_messaging_call_list_finish (
    MmGdbusModemMessaging *proxy,
    gchar ***out_result,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_messaging_call_list_sync (
    MmGdbusModemMessaging *proxy,
    gchar ***out_result,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_messaging_call_delete (
    MmGdbusModemMessaging *proxy,
    const gchar *arg_path,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_messaging_call_delete_finish (
    MmGdbusModemMessaging *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_messaging_call_delete_sync (
    MmGdbusModemMessaging *proxy,
    const gchar *arg_path,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_messaging_call_create (
    MmGdbusModemMessaging *proxy,
    GVariant *arg_properties,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_messaging_call_create_finish (
    MmGdbusModemMessaging *proxy,
    gchar **out_path,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_messaging_call_create_sync (
    MmGdbusModemMessaging *proxy,
    GVariant *arg_properties,
    gchar **out_path,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
const gchar *const *mm_gdbus_modem_messaging_get_messages (MmGdbusModemMessaging *object);
gchar **mm_gdbus_modem_messaging_dup_messages (MmGdbusModemMessaging *object);
void mm_gdbus_modem_messaging_set_messages (MmGdbusModemMessaging *object, const gchar *const *value);

GVariant *mm_gdbus_modem_messaging_get_supported_storages (MmGdbusModemMessaging *object);
GVariant *mm_gdbus_modem_messaging_dup_supported_storages (MmGdbusModemMessaging *object);
void mm_gdbus_modem_messaging_set_supported_storages (MmGdbusModemMessaging *object, GVariant *value);

guint mm_gdbus_modem_messaging_get_default_storage (MmGdbusModemMessaging *object);
void mm_gdbus_modem_messaging_set_default_storage (MmGdbusModemMessaging *object, guint value);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_MESSAGING_PROXY (mm_gdbus_modem_messaging_proxy_get_type ())
#define MM_GDBUS_MODEM_MESSAGING_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_MESSAGING_PROXY, MmGdbusModemMessagingProxy))
#define MM_GDBUS_MODEM_MESSAGING_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_MESSAGING_PROXY, MmGdbusModemMessagingProxyClass))
#define MM_GDBUS_MODEM_MESSAGING_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_MESSAGING_PROXY, MmGdbusModemMessagingProxyClass))
#define MM_GDBUS_IS_MODEM_MESSAGING_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_MESSAGING_PROXY))
#define MM_GDBUS_IS_MODEM_MESSAGING_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_MESSAGING_PROXY))

typedef struct _MmGdbusModemMessagingProxy MmGdbusModemMessagingProxy;
typedef struct _MmGdbusModemMessagingProxyClass MmGdbusModemMessagingProxyClass;
typedef struct _MmGdbusModemMessagingProxyPrivate MmGdbusModemMessagingProxyPrivate;

struct _MmGdbusModemMessagingProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  MmGdbusModemMessagingProxyPrivate *priv;
};

struct _MmGdbusModemMessagingProxyClass
{
  GDBusProxyClass parent_class;
};

GType mm_gdbus_modem_messaging_proxy_get_type (void) G_GNUC_CONST;

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

void mm_gdbus_modem_messaging_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemMessaging *mm_gdbus_modem_messaging_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemMessaging *mm_gdbus_modem_messaging_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void mm_gdbus_modem_messaging_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemMessaging *mm_gdbus_modem_messaging_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemMessaging *mm_gdbus_modem_messaging_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_MESSAGING_SKELETON (mm_gdbus_modem_messaging_skeleton_get_type ())
#define MM_GDBUS_MODEM_MESSAGING_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_MESSAGING_SKELETON, MmGdbusModemMessagingSkeleton))
#define MM_GDBUS_MODEM_MESSAGING_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_MESSAGING_SKELETON, MmGdbusModemMessagingSkeletonClass))
#define MM_GDBUS_MODEM_MESSAGING_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_MESSAGING_SKELETON, MmGdbusModemMessagingSkeletonClass))
#define MM_GDBUS_IS_MODEM_MESSAGING_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_MESSAGING_SKELETON))
#define MM_GDBUS_IS_MODEM_MESSAGING_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_MESSAGING_SKELETON))

typedef struct _MmGdbusModemMessagingSkeleton MmGdbusModemMessagingSkeleton;
typedef struct _MmGdbusModemMessagingSkeletonClass MmGdbusModemMessagingSkeletonClass;
typedef struct _MmGdbusModemMessagingSkeletonPrivate MmGdbusModemMessagingSkeletonPrivate;

struct _MmGdbusModemMessagingSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  MmGdbusModemMessagingSkeletonPrivate *priv;
};

struct _MmGdbusModemMessagingSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType mm_gdbus_modem_messaging_skeleton_get_type (void) G_GNUC_CONST;

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

MmGdbusModemMessaging *mm_gdbus_modem_messaging_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.ModemManager1.Modem.Voice */

#define MM_GDBUS_TYPE_MODEM_VOICE (mm_gdbus_modem_voice_get_type ())
#define MM_GDBUS_MODEM_VOICE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_VOICE, MmGdbusModemVoice))
#define MM_GDBUS_IS_MODEM_VOICE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_VOICE))
#define MM_GDBUS_MODEM_VOICE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), MM_GDBUS_TYPE_MODEM_VOICE, MmGdbusModemVoiceIface))

struct _MmGdbusModemVoice;
typedef struct _MmGdbusModemVoice MmGdbusModemVoice;
typedef struct _MmGdbusModemVoiceIface MmGdbusModemVoiceIface;

struct _MmGdbusModemVoiceIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_create_call) (
    MmGdbusModemVoice *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_properties);

  gboolean (*handle_delete_call) (
    MmGdbusModemVoice *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_path);

  gboolean (*handle_list_calls) (
    MmGdbusModemVoice *object,
    GDBusMethodInvocation *invocation);

  const gchar *const * (*get_calls) (MmGdbusModemVoice *object);

  void (*call_added) (
    MmGdbusModemVoice *object,
    const gchar *arg_path);

  void (*call_deleted) (
    MmGdbusModemVoice *object,
    const gchar *arg_path);

};

GType mm_gdbus_modem_voice_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *mm_gdbus_modem_voice_interface_info (void);
guint mm_gdbus_modem_voice_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void mm_gdbus_modem_voice_complete_list_calls (
    MmGdbusModemVoice *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *result);

void mm_gdbus_modem_voice_complete_delete_call (
    MmGdbusModemVoice *object,
    GDBusMethodInvocation *invocation);

void mm_gdbus_modem_voice_complete_create_call (
    MmGdbusModemVoice *object,
    GDBusMethodInvocation *invocation,
    const gchar *path);



/* D-Bus signal emissions functions: */
void mm_gdbus_modem_voice_emit_call_added (
    MmGdbusModemVoice *object,
    const gchar *arg_path);

void mm_gdbus_modem_voice_emit_call_deleted (
    MmGdbusModemVoice *object,
    const gchar *arg_path);



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

gboolean mm_gdbus_modem_voice_call_list_calls_finish (
    MmGdbusModemVoice *proxy,
    gchar ***out_result,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_voice_call_list_calls_sync (
    MmGdbusModemVoice *proxy,
    gchar ***out_result,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_voice_call_delete_call (
    MmGdbusModemVoice *proxy,
    const gchar *arg_path,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_voice_call_delete_call_finish (
    MmGdbusModemVoice *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_voice_call_delete_call_sync (
    MmGdbusModemVoice *proxy,
    const gchar *arg_path,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_voice_call_create_call (
    MmGdbusModemVoice *proxy,
    GVariant *arg_properties,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_voice_call_create_call_finish (
    MmGdbusModemVoice *proxy,
    gchar **out_path,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_voice_call_create_call_sync (
    MmGdbusModemVoice *proxy,
    GVariant *arg_properties,
    gchar **out_path,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
const gchar *const *mm_gdbus_modem_voice_get_calls (MmGdbusModemVoice *object);
gchar **mm_gdbus_modem_voice_dup_calls (MmGdbusModemVoice *object);
void mm_gdbus_modem_voice_set_calls (MmGdbusModemVoice *object, const gchar *const *value);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_VOICE_PROXY (mm_gdbus_modem_voice_proxy_get_type ())
#define MM_GDBUS_MODEM_VOICE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_VOICE_PROXY, MmGdbusModemVoiceProxy))
#define MM_GDBUS_MODEM_VOICE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_VOICE_PROXY, MmGdbusModemVoiceProxyClass))
#define MM_GDBUS_MODEM_VOICE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_VOICE_PROXY, MmGdbusModemVoiceProxyClass))
#define MM_GDBUS_IS_MODEM_VOICE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_VOICE_PROXY))
#define MM_GDBUS_IS_MODEM_VOICE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_VOICE_PROXY))

typedef struct _MmGdbusModemVoiceProxy MmGdbusModemVoiceProxy;
typedef struct _MmGdbusModemVoiceProxyClass MmGdbusModemVoiceProxyClass;
typedef struct _MmGdbusModemVoiceProxyPrivate MmGdbusModemVoiceProxyPrivate;

struct _MmGdbusModemVoiceProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  MmGdbusModemVoiceProxyPrivate *priv;
};

struct _MmGdbusModemVoiceProxyClass
{
  GDBusProxyClass parent_class;
};

GType mm_gdbus_modem_voice_proxy_get_type (void) G_GNUC_CONST;

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

void mm_gdbus_modem_voice_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemVoice *mm_gdbus_modem_voice_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemVoice *mm_gdbus_modem_voice_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void mm_gdbus_modem_voice_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemVoice *mm_gdbus_modem_voice_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemVoice *mm_gdbus_modem_voice_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_VOICE_SKELETON (mm_gdbus_modem_voice_skeleton_get_type ())
#define MM_GDBUS_MODEM_VOICE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_VOICE_SKELETON, MmGdbusModemVoiceSkeleton))
#define MM_GDBUS_MODEM_VOICE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_VOICE_SKELETON, MmGdbusModemVoiceSkeletonClass))
#define MM_GDBUS_MODEM_VOICE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_VOICE_SKELETON, MmGdbusModemVoiceSkeletonClass))
#define MM_GDBUS_IS_MODEM_VOICE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_VOICE_SKELETON))
#define MM_GDBUS_IS_MODEM_VOICE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_VOICE_SKELETON))

typedef struct _MmGdbusModemVoiceSkeleton MmGdbusModemVoiceSkeleton;
typedef struct _MmGdbusModemVoiceSkeletonClass MmGdbusModemVoiceSkeletonClass;
typedef struct _MmGdbusModemVoiceSkeletonPrivate MmGdbusModemVoiceSkeletonPrivate;

struct _MmGdbusModemVoiceSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  MmGdbusModemVoiceSkeletonPrivate *priv;
};

struct _MmGdbusModemVoiceSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType mm_gdbus_modem_voice_skeleton_get_type (void) G_GNUC_CONST;

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

MmGdbusModemVoice *mm_gdbus_modem_voice_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.ModemManager1.Modem.Location */

#define MM_GDBUS_TYPE_MODEM_LOCATION (mm_gdbus_modem_location_get_type ())
#define MM_GDBUS_MODEM_LOCATION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_LOCATION, MmGdbusModemLocation))
#define MM_GDBUS_IS_MODEM_LOCATION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_LOCATION))
#define MM_GDBUS_MODEM_LOCATION_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), MM_GDBUS_TYPE_MODEM_LOCATION, MmGdbusModemLocationIface))

struct _MmGdbusModemLocation;
typedef struct _MmGdbusModemLocation MmGdbusModemLocation;
typedef struct _MmGdbusModemLocationIface MmGdbusModemLocationIface;

struct _MmGdbusModemLocationIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_get_location) (
    MmGdbusModemLocation *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_set_gps_refresh_rate) (
    MmGdbusModemLocation *object,
    GDBusMethodInvocation *invocation,
    guint arg_rate);

  gboolean (*handle_set_supl_server) (
    MmGdbusModemLocation *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_supl);

  gboolean (*handle_setup) (
    MmGdbusModemLocation *object,
    GDBusMethodInvocation *invocation,
    guint arg_sources,
    gboolean arg_signal_location);

  guint  (*get_capabilities) (MmGdbusModemLocation *object);

  guint  (*get_enabled) (MmGdbusModemLocation *object);

  guint  (*get_gps_refresh_rate) (MmGdbusModemLocation *object);

  GVariant * (*get_location) (MmGdbusModemLocation *object);

  gboolean  (*get_signals_location) (MmGdbusModemLocation *object);

  const gchar * (*get_supl_server) (MmGdbusModemLocation *object);

};

GType mm_gdbus_modem_location_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *mm_gdbus_modem_location_interface_info (void);
guint mm_gdbus_modem_location_override_properties (GObjectClass *klass, guint property_id_begin);


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

void mm_gdbus_modem_location_complete_get_location (
    MmGdbusModemLocation *object,
    GDBusMethodInvocation *invocation,
    GVariant *Location);

void mm_gdbus_modem_location_complete_set_supl_server (
    MmGdbusModemLocation *object,
    GDBusMethodInvocation *invocation);

void mm_gdbus_modem_location_complete_set_gps_refresh_rate (
    MmGdbusModemLocation *object,
    GDBusMethodInvocation *invocation);



/* D-Bus method calls: */
void mm_gdbus_modem_location_call_setup (
    MmGdbusModemLocation *proxy,
    guint arg_sources,
    gboolean arg_signal_location,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_location_call_setup_finish (
    MmGdbusModemLocation *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_location_call_setup_sync (
    MmGdbusModemLocation *proxy,
    guint arg_sources,
    gboolean arg_signal_location,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_location_call_get_location (
    MmGdbusModemLocation *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_location_call_get_location_finish (
    MmGdbusModemLocation *proxy,
    GVariant **out_Location,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_location_call_get_location_sync (
    MmGdbusModemLocation *proxy,
    GVariant **out_Location,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_location_call_set_supl_server (
    MmGdbusModemLocation *proxy,
    const gchar *arg_supl,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_location_call_set_supl_server_finish (
    MmGdbusModemLocation *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_location_call_set_supl_server_sync (
    MmGdbusModemLocation *proxy,
    const gchar *arg_supl,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_location_call_set_gps_refresh_rate (
    MmGdbusModemLocation *proxy,
    guint arg_rate,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_location_call_set_gps_refresh_rate_finish (
    MmGdbusModemLocation *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_location_call_set_gps_refresh_rate_sync (
    MmGdbusModemLocation *proxy,
    guint arg_rate,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint mm_gdbus_modem_location_get_capabilities (MmGdbusModemLocation *object);
void mm_gdbus_modem_location_set_capabilities (MmGdbusModemLocation *object, guint value);

guint mm_gdbus_modem_location_get_enabled (MmGdbusModemLocation *object);
void mm_gdbus_modem_location_set_enabled (MmGdbusModemLocation *object, guint value);

gboolean mm_gdbus_modem_location_get_signals_location (MmGdbusModemLocation *object);
void mm_gdbus_modem_location_set_signals_location (MmGdbusModemLocation *object, gboolean value);

GVariant *mm_gdbus_modem_location_get_location (MmGdbusModemLocation *object);
GVariant *mm_gdbus_modem_location_dup_location (MmGdbusModemLocation *object);
void mm_gdbus_modem_location_set_location (MmGdbusModemLocation *object, GVariant *value);

const gchar *mm_gdbus_modem_location_get_supl_server (MmGdbusModemLocation *object);
gchar *mm_gdbus_modem_location_dup_supl_server (MmGdbusModemLocation *object);
void mm_gdbus_modem_location_set_supl_server (MmGdbusModemLocation *object, const gchar *value);

guint mm_gdbus_modem_location_get_gps_refresh_rate (MmGdbusModemLocation *object);
void mm_gdbus_modem_location_set_gps_refresh_rate (MmGdbusModemLocation *object, guint value);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_LOCATION_PROXY (mm_gdbus_modem_location_proxy_get_type ())
#define MM_GDBUS_MODEM_LOCATION_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_LOCATION_PROXY, MmGdbusModemLocationProxy))
#define MM_GDBUS_MODEM_LOCATION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_LOCATION_PROXY, MmGdbusModemLocationProxyClass))
#define MM_GDBUS_MODEM_LOCATION_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_LOCATION_PROXY, MmGdbusModemLocationProxyClass))
#define MM_GDBUS_IS_MODEM_LOCATION_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_LOCATION_PROXY))
#define MM_GDBUS_IS_MODEM_LOCATION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_LOCATION_PROXY))

typedef struct _MmGdbusModemLocationProxy MmGdbusModemLocationProxy;
typedef struct _MmGdbusModemLocationProxyClass MmGdbusModemLocationProxyClass;
typedef struct _MmGdbusModemLocationProxyPrivate MmGdbusModemLocationProxyPrivate;

struct _MmGdbusModemLocationProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  MmGdbusModemLocationProxyPrivate *priv;
};

struct _MmGdbusModemLocationProxyClass
{
  GDBusProxyClass parent_class;
};

GType mm_gdbus_modem_location_proxy_get_type (void) G_GNUC_CONST;

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

void mm_gdbus_modem_location_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemLocation *mm_gdbus_modem_location_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemLocation *mm_gdbus_modem_location_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void mm_gdbus_modem_location_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemLocation *mm_gdbus_modem_location_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemLocation *mm_gdbus_modem_location_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_LOCATION_SKELETON (mm_gdbus_modem_location_skeleton_get_type ())
#define MM_GDBUS_MODEM_LOCATION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_LOCATION_SKELETON, MmGdbusModemLocationSkeleton))
#define MM_GDBUS_MODEM_LOCATION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_LOCATION_SKELETON, MmGdbusModemLocationSkeletonClass))
#define MM_GDBUS_MODEM_LOCATION_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_LOCATION_SKELETON, MmGdbusModemLocationSkeletonClass))
#define MM_GDBUS_IS_MODEM_LOCATION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_LOCATION_SKELETON))
#define MM_GDBUS_IS_MODEM_LOCATION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_LOCATION_SKELETON))

typedef struct _MmGdbusModemLocationSkeleton MmGdbusModemLocationSkeleton;
typedef struct _MmGdbusModemLocationSkeletonClass MmGdbusModemLocationSkeletonClass;
typedef struct _MmGdbusModemLocationSkeletonPrivate MmGdbusModemLocationSkeletonPrivate;

struct _MmGdbusModemLocationSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  MmGdbusModemLocationSkeletonPrivate *priv;
};

struct _MmGdbusModemLocationSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType mm_gdbus_modem_location_skeleton_get_type (void) G_GNUC_CONST;

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

MmGdbusModemLocation *mm_gdbus_modem_location_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.ModemManager1.Modem.Time */

#define MM_GDBUS_TYPE_MODEM_TIME (mm_gdbus_modem_time_get_type ())
#define MM_GDBUS_MODEM_TIME(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_TIME, MmGdbusModemTime))
#define MM_GDBUS_IS_MODEM_TIME(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_TIME))
#define MM_GDBUS_MODEM_TIME_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), MM_GDBUS_TYPE_MODEM_TIME, MmGdbusModemTimeIface))

struct _MmGdbusModemTime;
typedef struct _MmGdbusModemTime MmGdbusModemTime;
typedef struct _MmGdbusModemTimeIface MmGdbusModemTimeIface;

struct _MmGdbusModemTimeIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_get_network_time) (
    MmGdbusModemTime *object,
    GDBusMethodInvocation *invocation);

  GVariant * (*get_network_timezone) (MmGdbusModemTime *object);

  void (*network_time_changed) (
    MmGdbusModemTime *object,
    const gchar *arg_time);

};

GType mm_gdbus_modem_time_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *mm_gdbus_modem_time_interface_info (void);
guint mm_gdbus_modem_time_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void mm_gdbus_modem_time_complete_get_network_time (
    MmGdbusModemTime *object,
    GDBusMethodInvocation *invocation,
    const gchar *time);



/* D-Bus signal emissions functions: */
void mm_gdbus_modem_time_emit_network_time_changed (
    MmGdbusModemTime *object,
    const gchar *arg_time);



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

gboolean mm_gdbus_modem_time_call_get_network_time_finish (
    MmGdbusModemTime *proxy,
    gchar **out_time,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_time_call_get_network_time_sync (
    MmGdbusModemTime *proxy,
    gchar **out_time,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
GVariant *mm_gdbus_modem_time_get_network_timezone (MmGdbusModemTime *object);
GVariant *mm_gdbus_modem_time_dup_network_timezone (MmGdbusModemTime *object);
void mm_gdbus_modem_time_set_network_timezone (MmGdbusModemTime *object, GVariant *value);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_TIME_PROXY (mm_gdbus_modem_time_proxy_get_type ())
#define MM_GDBUS_MODEM_TIME_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_TIME_PROXY, MmGdbusModemTimeProxy))
#define MM_GDBUS_MODEM_TIME_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_TIME_PROXY, MmGdbusModemTimeProxyClass))
#define MM_GDBUS_MODEM_TIME_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_TIME_PROXY, MmGdbusModemTimeProxyClass))
#define MM_GDBUS_IS_MODEM_TIME_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_TIME_PROXY))
#define MM_GDBUS_IS_MODEM_TIME_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_TIME_PROXY))

typedef struct _MmGdbusModemTimeProxy MmGdbusModemTimeProxy;
typedef struct _MmGdbusModemTimeProxyClass MmGdbusModemTimeProxyClass;
typedef struct _MmGdbusModemTimeProxyPrivate MmGdbusModemTimeProxyPrivate;

struct _MmGdbusModemTimeProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  MmGdbusModemTimeProxyPrivate *priv;
};

struct _MmGdbusModemTimeProxyClass
{
  GDBusProxyClass parent_class;
};

GType mm_gdbus_modem_time_proxy_get_type (void) G_GNUC_CONST;

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

void mm_gdbus_modem_time_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemTime *mm_gdbus_modem_time_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemTime *mm_gdbus_modem_time_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void mm_gdbus_modem_time_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemTime *mm_gdbus_modem_time_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemTime *mm_gdbus_modem_time_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_TIME_SKELETON (mm_gdbus_modem_time_skeleton_get_type ())
#define MM_GDBUS_MODEM_TIME_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_TIME_SKELETON, MmGdbusModemTimeSkeleton))
#define MM_GDBUS_MODEM_TIME_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_TIME_SKELETON, MmGdbusModemTimeSkeletonClass))
#define MM_GDBUS_MODEM_TIME_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_TIME_SKELETON, MmGdbusModemTimeSkeletonClass))
#define MM_GDBUS_IS_MODEM_TIME_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_TIME_SKELETON))
#define MM_GDBUS_IS_MODEM_TIME_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_TIME_SKELETON))

typedef struct _MmGdbusModemTimeSkeleton MmGdbusModemTimeSkeleton;
typedef struct _MmGdbusModemTimeSkeletonClass MmGdbusModemTimeSkeletonClass;
typedef struct _MmGdbusModemTimeSkeletonPrivate MmGdbusModemTimeSkeletonPrivate;

struct _MmGdbusModemTimeSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  MmGdbusModemTimeSkeletonPrivate *priv;
};

struct _MmGdbusModemTimeSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType mm_gdbus_modem_time_skeleton_get_type (void) G_GNUC_CONST;

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

MmGdbusModemTime *mm_gdbus_modem_time_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.ModemManager1.Modem.Firmware */

#define MM_GDBUS_TYPE_MODEM_FIRMWARE (mm_gdbus_modem_firmware_get_type ())
#define MM_GDBUS_MODEM_FIRMWARE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_FIRMWARE, MmGdbusModemFirmware))
#define MM_GDBUS_IS_MODEM_FIRMWARE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_FIRMWARE))
#define MM_GDBUS_MODEM_FIRMWARE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), MM_GDBUS_TYPE_MODEM_FIRMWARE, MmGdbusModemFirmwareIface))

struct _MmGdbusModemFirmware;
typedef struct _MmGdbusModemFirmware MmGdbusModemFirmware;
typedef struct _MmGdbusModemFirmwareIface MmGdbusModemFirmwareIface;

struct _MmGdbusModemFirmwareIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_list) (
    MmGdbusModemFirmware *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_select) (
    MmGdbusModemFirmware *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_uniqueid);

};

GType mm_gdbus_modem_firmware_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *mm_gdbus_modem_firmware_interface_info (void);
guint mm_gdbus_modem_firmware_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void mm_gdbus_modem_firmware_complete_list (
    MmGdbusModemFirmware *object,
    GDBusMethodInvocation *invocation,
    const gchar *selected,
    GVariant *installed);

void mm_gdbus_modem_firmware_complete_select (
    MmGdbusModemFirmware *object,
    GDBusMethodInvocation *invocation);



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

gboolean mm_gdbus_modem_firmware_call_list_finish (
    MmGdbusModemFirmware *proxy,
    gchar **out_selected,
    GVariant **out_installed,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_firmware_call_list_sync (
    MmGdbusModemFirmware *proxy,
    gchar **out_selected,
    GVariant **out_installed,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_firmware_call_select (
    MmGdbusModemFirmware *proxy,
    const gchar *arg_uniqueid,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_firmware_call_select_finish (
    MmGdbusModemFirmware *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_firmware_call_select_sync (
    MmGdbusModemFirmware *proxy,
    const gchar *arg_uniqueid,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define MM_GDBUS_TYPE_MODEM_FIRMWARE_PROXY (mm_gdbus_modem_firmware_proxy_get_type ())
#define MM_GDBUS_MODEM_FIRMWARE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_FIRMWARE_PROXY, MmGdbusModemFirmwareProxy))
#define MM_GDBUS_MODEM_FIRMWARE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_FIRMWARE_PROXY, MmGdbusModemFirmwareProxyClass))
#define MM_GDBUS_MODEM_FIRMWARE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_FIRMWARE_PROXY, MmGdbusModemFirmwareProxyClass))
#define MM_GDBUS_IS_MODEM_FIRMWARE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_FIRMWARE_PROXY))
#define MM_GDBUS_IS_MODEM_FIRMWARE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_FIRMWARE_PROXY))

typedef struct _MmGdbusModemFirmwareProxy MmGdbusModemFirmwareProxy;
typedef struct _MmGdbusModemFirmwareProxyClass MmGdbusModemFirmwareProxyClass;
typedef struct _MmGdbusModemFirmwareProxyPrivate MmGdbusModemFirmwareProxyPrivate;

struct _MmGdbusModemFirmwareProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  MmGdbusModemFirmwareProxyPrivate *priv;
};

struct _MmGdbusModemFirmwareProxyClass
{
  GDBusProxyClass parent_class;
};

GType mm_gdbus_modem_firmware_proxy_get_type (void) G_GNUC_CONST;

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

void mm_gdbus_modem_firmware_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemFirmware *mm_gdbus_modem_firmware_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemFirmware *mm_gdbus_modem_firmware_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void mm_gdbus_modem_firmware_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemFirmware *mm_gdbus_modem_firmware_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemFirmware *mm_gdbus_modem_firmware_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_FIRMWARE_SKELETON (mm_gdbus_modem_firmware_skeleton_get_type ())
#define MM_GDBUS_MODEM_FIRMWARE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_FIRMWARE_SKELETON, MmGdbusModemFirmwareSkeleton))
#define MM_GDBUS_MODEM_FIRMWARE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_FIRMWARE_SKELETON, MmGdbusModemFirmwareSkeletonClass))
#define MM_GDBUS_MODEM_FIRMWARE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_FIRMWARE_SKELETON, MmGdbusModemFirmwareSkeletonClass))
#define MM_GDBUS_IS_MODEM_FIRMWARE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_FIRMWARE_SKELETON))
#define MM_GDBUS_IS_MODEM_FIRMWARE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_FIRMWARE_SKELETON))

typedef struct _MmGdbusModemFirmwareSkeleton MmGdbusModemFirmwareSkeleton;
typedef struct _MmGdbusModemFirmwareSkeletonClass MmGdbusModemFirmwareSkeletonClass;
typedef struct _MmGdbusModemFirmwareSkeletonPrivate MmGdbusModemFirmwareSkeletonPrivate;

struct _MmGdbusModemFirmwareSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  MmGdbusModemFirmwareSkeletonPrivate *priv;
};

struct _MmGdbusModemFirmwareSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType mm_gdbus_modem_firmware_skeleton_get_type (void) G_GNUC_CONST;

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

MmGdbusModemFirmware *mm_gdbus_modem_firmware_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.ModemManager1.Modem.Oma */

#define MM_GDBUS_TYPE_MODEM_OMA (mm_gdbus_modem_oma_get_type ())
#define MM_GDBUS_MODEM_OMA(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_OMA, MmGdbusModemOma))
#define MM_GDBUS_IS_MODEM_OMA(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_OMA))
#define MM_GDBUS_MODEM_OMA_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), MM_GDBUS_TYPE_MODEM_OMA, MmGdbusModemOmaIface))

struct _MmGdbusModemOma;
typedef struct _MmGdbusModemOma MmGdbusModemOma;
typedef struct _MmGdbusModemOmaIface MmGdbusModemOmaIface;

struct _MmGdbusModemOmaIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_accept_network_initiated_session) (
    MmGdbusModemOma *object,
    GDBusMethodInvocation *invocation,
    guint arg_session_id,
    gboolean arg_accept);

  gboolean (*handle_cancel_session) (
    MmGdbusModemOma *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_setup) (
    MmGdbusModemOma *object,
    GDBusMethodInvocation *invocation,
    guint arg_features);

  gboolean (*handle_start_client_initiated_session) (
    MmGdbusModemOma *object,
    GDBusMethodInvocation *invocation,
    guint arg_session_type);

  guint  (*get_features) (MmGdbusModemOma *object);

  GVariant * (*get_pending_network_initiated_sessions) (MmGdbusModemOma *object);

  gint  (*get_session_state) (MmGdbusModemOma *object);

  guint  (*get_session_type) (MmGdbusModemOma *object);

  void (*session_state_changed) (
    MmGdbusModemOma *object,
    gint arg_old_session_state,
    gint arg_new_session_state,
    guint arg_session_state_failed_reason);

};

GType mm_gdbus_modem_oma_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *mm_gdbus_modem_oma_interface_info (void);
guint mm_gdbus_modem_oma_override_properties (GObjectClass *klass, guint property_id_begin);


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

void mm_gdbus_modem_oma_complete_start_client_initiated_session (
    MmGdbusModemOma *object,
    GDBusMethodInvocation *invocation);

void mm_gdbus_modem_oma_complete_accept_network_initiated_session (
    MmGdbusModemOma *object,
    GDBusMethodInvocation *invocation);

void mm_gdbus_modem_oma_complete_cancel_session (
    MmGdbusModemOma *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void mm_gdbus_modem_oma_emit_session_state_changed (
    MmGdbusModemOma *object,
    gint arg_old_session_state,
    gint arg_new_session_state,
    guint arg_session_state_failed_reason);



/* D-Bus method calls: */
void mm_gdbus_modem_oma_call_setup (
    MmGdbusModemOma *proxy,
    guint arg_features,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_oma_call_setup_finish (
    MmGdbusModemOma *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_oma_call_setup_sync (
    MmGdbusModemOma *proxy,
    guint arg_features,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_oma_call_start_client_initiated_session (
    MmGdbusModemOma *proxy,
    guint arg_session_type,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_oma_call_start_client_initiated_session_finish (
    MmGdbusModemOma *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_oma_call_start_client_initiated_session_sync (
    MmGdbusModemOma *proxy,
    guint arg_session_type,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_oma_call_accept_network_initiated_session (
    MmGdbusModemOma *proxy,
    guint arg_session_id,
    gboolean arg_accept,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_oma_call_accept_network_initiated_session_finish (
    MmGdbusModemOma *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_oma_call_accept_network_initiated_session_sync (
    MmGdbusModemOma *proxy,
    guint arg_session_id,
    gboolean arg_accept,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_oma_call_cancel_session (
    MmGdbusModemOma *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_oma_call_cancel_session_finish (
    MmGdbusModemOma *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_oma_call_cancel_session_sync (
    MmGdbusModemOma *proxy,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint mm_gdbus_modem_oma_get_features (MmGdbusModemOma *object);
void mm_gdbus_modem_oma_set_features (MmGdbusModemOma *object, guint value);

GVariant *mm_gdbus_modem_oma_get_pending_network_initiated_sessions (MmGdbusModemOma *object);
GVariant *mm_gdbus_modem_oma_dup_pending_network_initiated_sessions (MmGdbusModemOma *object);
void mm_gdbus_modem_oma_set_pending_network_initiated_sessions (MmGdbusModemOma *object, GVariant *value);

guint mm_gdbus_modem_oma_get_session_type (MmGdbusModemOma *object);
void mm_gdbus_modem_oma_set_session_type (MmGdbusModemOma *object, guint value);

gint mm_gdbus_modem_oma_get_session_state (MmGdbusModemOma *object);
void mm_gdbus_modem_oma_set_session_state (MmGdbusModemOma *object, gint value);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_OMA_PROXY (mm_gdbus_modem_oma_proxy_get_type ())
#define MM_GDBUS_MODEM_OMA_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_OMA_PROXY, MmGdbusModemOmaProxy))
#define MM_GDBUS_MODEM_OMA_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_OMA_PROXY, MmGdbusModemOmaProxyClass))
#define MM_GDBUS_MODEM_OMA_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_OMA_PROXY, MmGdbusModemOmaProxyClass))
#define MM_GDBUS_IS_MODEM_OMA_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_OMA_PROXY))
#define MM_GDBUS_IS_MODEM_OMA_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_OMA_PROXY))

typedef struct _MmGdbusModemOmaProxy MmGdbusModemOmaProxy;
typedef struct _MmGdbusModemOmaProxyClass MmGdbusModemOmaProxyClass;
typedef struct _MmGdbusModemOmaProxyPrivate MmGdbusModemOmaProxyPrivate;

struct _MmGdbusModemOmaProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  MmGdbusModemOmaProxyPrivate *priv;
};

struct _MmGdbusModemOmaProxyClass
{
  GDBusProxyClass parent_class;
};

GType mm_gdbus_modem_oma_proxy_get_type (void) G_GNUC_CONST;

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

void mm_gdbus_modem_oma_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemOma *mm_gdbus_modem_oma_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemOma *mm_gdbus_modem_oma_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void mm_gdbus_modem_oma_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemOma *mm_gdbus_modem_oma_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemOma *mm_gdbus_modem_oma_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_OMA_SKELETON (mm_gdbus_modem_oma_skeleton_get_type ())
#define MM_GDBUS_MODEM_OMA_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_OMA_SKELETON, MmGdbusModemOmaSkeleton))
#define MM_GDBUS_MODEM_OMA_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_OMA_SKELETON, MmGdbusModemOmaSkeletonClass))
#define MM_GDBUS_MODEM_OMA_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_OMA_SKELETON, MmGdbusModemOmaSkeletonClass))
#define MM_GDBUS_IS_MODEM_OMA_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_OMA_SKELETON))
#define MM_GDBUS_IS_MODEM_OMA_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_OMA_SKELETON))

typedef struct _MmGdbusModemOmaSkeleton MmGdbusModemOmaSkeleton;
typedef struct _MmGdbusModemOmaSkeletonClass MmGdbusModemOmaSkeletonClass;
typedef struct _MmGdbusModemOmaSkeletonPrivate MmGdbusModemOmaSkeletonPrivate;

struct _MmGdbusModemOmaSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  MmGdbusModemOmaSkeletonPrivate *priv;
};

struct _MmGdbusModemOmaSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType mm_gdbus_modem_oma_skeleton_get_type (void) G_GNUC_CONST;

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

MmGdbusModemOma *mm_gdbus_modem_oma_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.ModemManager1.Modem.ModemCdma */

#define MM_GDBUS_TYPE_MODEM_CDMA (mm_gdbus_modem_cdma_get_type ())
#define MM_GDBUS_MODEM_CDMA(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_CDMA, MmGdbusModemCdma))
#define MM_GDBUS_IS_MODEM_CDMA(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_CDMA))
#define MM_GDBUS_MODEM_CDMA_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), MM_GDBUS_TYPE_MODEM_CDMA, MmGdbusModemCdmaIface))

struct _MmGdbusModemCdma;
typedef struct _MmGdbusModemCdma MmGdbusModemCdma;
typedef struct _MmGdbusModemCdmaIface MmGdbusModemCdmaIface;

struct _MmGdbusModemCdmaIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_activate) (
    MmGdbusModemCdma *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_carrier_code);

  gboolean (*handle_activate_manual) (
    MmGdbusModemCdma *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_properties);

  guint  (*get_activation_state) (MmGdbusModemCdma *object);

  guint  (*get_cdma1x_registration_state) (MmGdbusModemCdma *object);

  const gchar * (*get_esn) (MmGdbusModemCdma *object);

  guint  (*get_evdo_registration_state) (MmGdbusModemCdma *object);

  const gchar * (*get_meid) (MmGdbusModemCdma *object);

  guint  (*get_nid) (MmGdbusModemCdma *object);

  guint  (*get_sid) (MmGdbusModemCdma *object);

  void (*activation_state_changed) (
    MmGdbusModemCdma *object,
    guint arg_activation_state,
    guint arg_activation_error,
    GVariant *arg_status_changes);

};

GType mm_gdbus_modem_cdma_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *mm_gdbus_modem_cdma_interface_info (void);
guint mm_gdbus_modem_cdma_override_properties (GObjectClass *klass, guint property_id_begin);


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

void mm_gdbus_modem_cdma_complete_activate_manual (
    MmGdbusModemCdma *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void mm_gdbus_modem_cdma_emit_activation_state_changed (
    MmGdbusModemCdma *object,
    guint arg_activation_state,
    guint arg_activation_error,
    GVariant *arg_status_changes);



/* D-Bus method calls: */
void mm_gdbus_modem_cdma_call_activate (
    MmGdbusModemCdma *proxy,
    const gchar *arg_carrier_code,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_cdma_call_activate_finish (
    MmGdbusModemCdma *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_cdma_call_activate_sync (
    MmGdbusModemCdma *proxy,
    const gchar *arg_carrier_code,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_cdma_call_activate_manual (
    MmGdbusModemCdma *proxy,
    GVariant *arg_properties,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_cdma_call_activate_manual_finish (
    MmGdbusModemCdma *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_cdma_call_activate_manual_sync (
    MmGdbusModemCdma *proxy,
    GVariant *arg_properties,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint mm_gdbus_modem_cdma_get_activation_state (MmGdbusModemCdma *object);
void mm_gdbus_modem_cdma_set_activation_state (MmGdbusModemCdma *object, guint value);

const gchar *mm_gdbus_modem_cdma_get_meid (MmGdbusModemCdma *object);
gchar *mm_gdbus_modem_cdma_dup_meid (MmGdbusModemCdma *object);
void mm_gdbus_modem_cdma_set_meid (MmGdbusModemCdma *object, const gchar *value);

const gchar *mm_gdbus_modem_cdma_get_esn (MmGdbusModemCdma *object);
gchar *mm_gdbus_modem_cdma_dup_esn (MmGdbusModemCdma *object);
void mm_gdbus_modem_cdma_set_esn (MmGdbusModemCdma *object, const gchar *value);

guint mm_gdbus_modem_cdma_get_sid (MmGdbusModemCdma *object);
void mm_gdbus_modem_cdma_set_sid (MmGdbusModemCdma *object, guint value);

guint mm_gdbus_modem_cdma_get_nid (MmGdbusModemCdma *object);
void mm_gdbus_modem_cdma_set_nid (MmGdbusModemCdma *object, guint value);

guint mm_gdbus_modem_cdma_get_cdma1x_registration_state (MmGdbusModemCdma *object);
void mm_gdbus_modem_cdma_set_cdma1x_registration_state (MmGdbusModemCdma *object, guint value);

guint mm_gdbus_modem_cdma_get_evdo_registration_state (MmGdbusModemCdma *object);
void mm_gdbus_modem_cdma_set_evdo_registration_state (MmGdbusModemCdma *object, guint value);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_CDMA_PROXY (mm_gdbus_modem_cdma_proxy_get_type ())
#define MM_GDBUS_MODEM_CDMA_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_CDMA_PROXY, MmGdbusModemCdmaProxy))
#define MM_GDBUS_MODEM_CDMA_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_CDMA_PROXY, MmGdbusModemCdmaProxyClass))
#define MM_GDBUS_MODEM_CDMA_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_CDMA_PROXY, MmGdbusModemCdmaProxyClass))
#define MM_GDBUS_IS_MODEM_CDMA_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_CDMA_PROXY))
#define MM_GDBUS_IS_MODEM_CDMA_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_CDMA_PROXY))

typedef struct _MmGdbusModemCdmaProxy MmGdbusModemCdmaProxy;
typedef struct _MmGdbusModemCdmaProxyClass MmGdbusModemCdmaProxyClass;
typedef struct _MmGdbusModemCdmaProxyPrivate MmGdbusModemCdmaProxyPrivate;

struct _MmGdbusModemCdmaProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  MmGdbusModemCdmaProxyPrivate *priv;
};

struct _MmGdbusModemCdmaProxyClass
{
  GDBusProxyClass parent_class;
};

GType mm_gdbus_modem_cdma_proxy_get_type (void) G_GNUC_CONST;

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

void mm_gdbus_modem_cdma_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemCdma *mm_gdbus_modem_cdma_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemCdma *mm_gdbus_modem_cdma_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void mm_gdbus_modem_cdma_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemCdma *mm_gdbus_modem_cdma_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemCdma *mm_gdbus_modem_cdma_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_CDMA_SKELETON (mm_gdbus_modem_cdma_skeleton_get_type ())
#define MM_GDBUS_MODEM_CDMA_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_CDMA_SKELETON, MmGdbusModemCdmaSkeleton))
#define MM_GDBUS_MODEM_CDMA_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_CDMA_SKELETON, MmGdbusModemCdmaSkeletonClass))
#define MM_GDBUS_MODEM_CDMA_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_CDMA_SKELETON, MmGdbusModemCdmaSkeletonClass))
#define MM_GDBUS_IS_MODEM_CDMA_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_CDMA_SKELETON))
#define MM_GDBUS_IS_MODEM_CDMA_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_CDMA_SKELETON))

typedef struct _MmGdbusModemCdmaSkeleton MmGdbusModemCdmaSkeleton;
typedef struct _MmGdbusModemCdmaSkeletonClass MmGdbusModemCdmaSkeletonClass;
typedef struct _MmGdbusModemCdmaSkeletonPrivate MmGdbusModemCdmaSkeletonPrivate;

struct _MmGdbusModemCdmaSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  MmGdbusModemCdmaSkeletonPrivate *priv;
};

struct _MmGdbusModemCdmaSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType mm_gdbus_modem_cdma_skeleton_get_type (void) G_GNUC_CONST;

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

MmGdbusModemCdma *mm_gdbus_modem_cdma_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.ModemManager1.Modem.Modem3gpp */

#define MM_GDBUS_TYPE_MODEM3GPP (mm_gdbus_modem3gpp_get_type ())
#define MM_GDBUS_MODEM3GPP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM3GPP, MmGdbusModem3gpp))
#define MM_GDBUS_IS_MODEM3GPP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM3GPP))
#define MM_GDBUS_MODEM3GPP_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), MM_GDBUS_TYPE_MODEM3GPP, MmGdbusModem3gppIface))

struct _MmGdbusModem3gpp;
typedef struct _MmGdbusModem3gpp MmGdbusModem3gpp;
typedef struct _MmGdbusModem3gppIface MmGdbusModem3gppIface;

struct _MmGdbusModem3gppIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_register) (
    MmGdbusModem3gpp *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_operator_id);

  gboolean (*handle_scan) (
    MmGdbusModem3gpp *object,
    GDBusMethodInvocation *invocation);

  guint  (*get_enabled_facility_locks) (MmGdbusModem3gpp *object);

  const gchar * (*get_imei) (MmGdbusModem3gpp *object);

  const gchar * (*get_operator_code) (MmGdbusModem3gpp *object);

  const gchar * (*get_operator_name) (MmGdbusModem3gpp *object);

  guint  (*get_registration_state) (MmGdbusModem3gpp *object);

  guint  (*get_subscription_state) (MmGdbusModem3gpp *object);

};

GType mm_gdbus_modem3gpp_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *mm_gdbus_modem3gpp_interface_info (void);
guint mm_gdbus_modem3gpp_override_properties (GObjectClass *klass, guint property_id_begin);


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

void mm_gdbus_modem3gpp_complete_scan (
    MmGdbusModem3gpp *object,
    GDBusMethodInvocation *invocation,
    GVariant *results);



/* D-Bus method calls: */
void mm_gdbus_modem3gpp_call_register (
    MmGdbusModem3gpp *proxy,
    const gchar *arg_operator_id,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem3gpp_call_register_finish (
    MmGdbusModem3gpp *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem3gpp_call_register_sync (
    MmGdbusModem3gpp *proxy,
    const gchar *arg_operator_id,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem3gpp_call_scan (
    MmGdbusModem3gpp *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem3gpp_call_scan_finish (
    MmGdbusModem3gpp *proxy,
    GVariant **out_results,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem3gpp_call_scan_sync (
    MmGdbusModem3gpp *proxy,
    GVariant **out_results,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
const gchar *mm_gdbus_modem3gpp_get_imei (MmGdbusModem3gpp *object);
gchar *mm_gdbus_modem3gpp_dup_imei (MmGdbusModem3gpp *object);
void mm_gdbus_modem3gpp_set_imei (MmGdbusModem3gpp *object, const gchar *value);

guint mm_gdbus_modem3gpp_get_registration_state (MmGdbusModem3gpp *object);
void mm_gdbus_modem3gpp_set_registration_state (MmGdbusModem3gpp *object, guint value);

const gchar *mm_gdbus_modem3gpp_get_operator_code (MmGdbusModem3gpp *object);
gchar *mm_gdbus_modem3gpp_dup_operator_code (MmGdbusModem3gpp *object);
void mm_gdbus_modem3gpp_set_operator_code (MmGdbusModem3gpp *object, const gchar *value);

const gchar *mm_gdbus_modem3gpp_get_operator_name (MmGdbusModem3gpp *object);
gchar *mm_gdbus_modem3gpp_dup_operator_name (MmGdbusModem3gpp *object);
void mm_gdbus_modem3gpp_set_operator_name (MmGdbusModem3gpp *object, const gchar *value);

guint mm_gdbus_modem3gpp_get_enabled_facility_locks (MmGdbusModem3gpp *object);
void mm_gdbus_modem3gpp_set_enabled_facility_locks (MmGdbusModem3gpp *object, guint value);

guint mm_gdbus_modem3gpp_get_subscription_state (MmGdbusModem3gpp *object);
void mm_gdbus_modem3gpp_set_subscription_state (MmGdbusModem3gpp *object, guint value);


/* ---- */

#define MM_GDBUS_TYPE_MODEM3GPP_PROXY (mm_gdbus_modem3gpp_proxy_get_type ())
#define MM_GDBUS_MODEM3GPP_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM3GPP_PROXY, MmGdbusModem3gppProxy))
#define MM_GDBUS_MODEM3GPP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM3GPP_PROXY, MmGdbusModem3gppProxyClass))
#define MM_GDBUS_MODEM3GPP_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM3GPP_PROXY, MmGdbusModem3gppProxyClass))
#define MM_GDBUS_IS_MODEM3GPP_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM3GPP_PROXY))
#define MM_GDBUS_IS_MODEM3GPP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM3GPP_PROXY))

typedef struct _MmGdbusModem3gppProxy MmGdbusModem3gppProxy;
typedef struct _MmGdbusModem3gppProxyClass MmGdbusModem3gppProxyClass;
typedef struct _MmGdbusModem3gppProxyPrivate MmGdbusModem3gppProxyPrivate;

struct _MmGdbusModem3gppProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  MmGdbusModem3gppProxyPrivate *priv;
};

struct _MmGdbusModem3gppProxyClass
{
  GDBusProxyClass parent_class;
};

GType mm_gdbus_modem3gpp_proxy_get_type (void) G_GNUC_CONST;

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

void mm_gdbus_modem3gpp_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModem3gpp *mm_gdbus_modem3gpp_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModem3gpp *mm_gdbus_modem3gpp_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void mm_gdbus_modem3gpp_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModem3gpp *mm_gdbus_modem3gpp_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModem3gpp *mm_gdbus_modem3gpp_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define MM_GDBUS_TYPE_MODEM3GPP_SKELETON (mm_gdbus_modem3gpp_skeleton_get_type ())
#define MM_GDBUS_MODEM3GPP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM3GPP_SKELETON, MmGdbusModem3gppSkeleton))
#define MM_GDBUS_MODEM3GPP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM3GPP_SKELETON, MmGdbusModem3gppSkeletonClass))
#define MM_GDBUS_MODEM3GPP_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM3GPP_SKELETON, MmGdbusModem3gppSkeletonClass))
#define MM_GDBUS_IS_MODEM3GPP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM3GPP_SKELETON))
#define MM_GDBUS_IS_MODEM3GPP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM3GPP_SKELETON))

typedef struct _MmGdbusModem3gppSkeleton MmGdbusModem3gppSkeleton;
typedef struct _MmGdbusModem3gppSkeletonClass MmGdbusModem3gppSkeletonClass;
typedef struct _MmGdbusModem3gppSkeletonPrivate MmGdbusModem3gppSkeletonPrivate;

struct _MmGdbusModem3gppSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  MmGdbusModem3gppSkeletonPrivate *priv;
};

struct _MmGdbusModem3gppSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType mm_gdbus_modem3gpp_skeleton_get_type (void) G_GNUC_CONST;

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

MmGdbusModem3gpp *mm_gdbus_modem3gpp_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.ModemManager1.Modem.Modem3gpp.Ussd */

#define MM_GDBUS_TYPE_MODEM3GPP_USSD (mm_gdbus_modem3gpp_ussd_get_type ())
#define MM_GDBUS_MODEM3GPP_USSD(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM3GPP_USSD, MmGdbusModem3gppUssd))
#define MM_GDBUS_IS_MODEM3GPP_USSD(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM3GPP_USSD))
#define MM_GDBUS_MODEM3GPP_USSD_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), MM_GDBUS_TYPE_MODEM3GPP_USSD, MmGdbusModem3gppUssdIface))

struct _MmGdbusModem3gppUssd;
typedef struct _MmGdbusModem3gppUssd MmGdbusModem3gppUssd;
typedef struct _MmGdbusModem3gppUssdIface MmGdbusModem3gppUssdIface;

struct _MmGdbusModem3gppUssdIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_cancel) (
    MmGdbusModem3gppUssd *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_initiate) (
    MmGdbusModem3gppUssd *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_command);

  gboolean (*handle_respond) (
    MmGdbusModem3gppUssd *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_response);

  const gchar * (*get_network_notification) (MmGdbusModem3gppUssd *object);

  const gchar * (*get_network_request) (MmGdbusModem3gppUssd *object);

  guint  (*get_state) (MmGdbusModem3gppUssd *object);

};

GType mm_gdbus_modem3gpp_ussd_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *mm_gdbus_modem3gpp_ussd_interface_info (void);
guint mm_gdbus_modem3gpp_ussd_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void mm_gdbus_modem3gpp_ussd_complete_initiate (
    MmGdbusModem3gppUssd *object,
    GDBusMethodInvocation *invocation,
    const gchar *reply);

void mm_gdbus_modem3gpp_ussd_complete_respond (
    MmGdbusModem3gppUssd *object,
    GDBusMethodInvocation *invocation,
    const gchar *reply);

void mm_gdbus_modem3gpp_ussd_complete_cancel (
    MmGdbusModem3gppUssd *object,
    GDBusMethodInvocation *invocation);



/* D-Bus method calls: */
void mm_gdbus_modem3gpp_ussd_call_initiate (
    MmGdbusModem3gppUssd *proxy,
    const gchar *arg_command,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem3gpp_ussd_call_initiate_finish (
    MmGdbusModem3gppUssd *proxy,
    gchar **out_reply,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem3gpp_ussd_call_initiate_sync (
    MmGdbusModem3gppUssd *proxy,
    const gchar *arg_command,
    gchar **out_reply,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem3gpp_ussd_call_respond (
    MmGdbusModem3gppUssd *proxy,
    const gchar *arg_response,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem3gpp_ussd_call_respond_finish (
    MmGdbusModem3gppUssd *proxy,
    gchar **out_reply,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem3gpp_ussd_call_respond_sync (
    MmGdbusModem3gppUssd *proxy,
    const gchar *arg_response,
    gchar **out_reply,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem3gpp_ussd_call_cancel (
    MmGdbusModem3gppUssd *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem3gpp_ussd_call_cancel_finish (
    MmGdbusModem3gppUssd *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem3gpp_ussd_call_cancel_sync (
    MmGdbusModem3gppUssd *proxy,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint mm_gdbus_modem3gpp_ussd_get_state (MmGdbusModem3gppUssd *object);
void mm_gdbus_modem3gpp_ussd_set_state (MmGdbusModem3gppUssd *object, guint value);

const gchar *mm_gdbus_modem3gpp_ussd_get_network_notification (MmGdbusModem3gppUssd *object);
gchar *mm_gdbus_modem3gpp_ussd_dup_network_notification (MmGdbusModem3gppUssd *object);
void mm_gdbus_modem3gpp_ussd_set_network_notification (MmGdbusModem3gppUssd *object, const gchar *value);

const gchar *mm_gdbus_modem3gpp_ussd_get_network_request (MmGdbusModem3gppUssd *object);
gchar *mm_gdbus_modem3gpp_ussd_dup_network_request (MmGdbusModem3gppUssd *object);
void mm_gdbus_modem3gpp_ussd_set_network_request (MmGdbusModem3gppUssd *object, const gchar *value);


/* ---- */

#define MM_GDBUS_TYPE_MODEM3GPP_USSD_PROXY (mm_gdbus_modem3gpp_ussd_proxy_get_type ())
#define MM_GDBUS_MODEM3GPP_USSD_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM3GPP_USSD_PROXY, MmGdbusModem3gppUssdProxy))
#define MM_GDBUS_MODEM3GPP_USSD_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM3GPP_USSD_PROXY, MmGdbusModem3gppUssdProxyClass))
#define MM_GDBUS_MODEM3GPP_USSD_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM3GPP_USSD_PROXY, MmGdbusModem3gppUssdProxyClass))
#define MM_GDBUS_IS_MODEM3GPP_USSD_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM3GPP_USSD_PROXY))
#define MM_GDBUS_IS_MODEM3GPP_USSD_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM3GPP_USSD_PROXY))

typedef struct _MmGdbusModem3gppUssdProxy MmGdbusModem3gppUssdProxy;
typedef struct _MmGdbusModem3gppUssdProxyClass MmGdbusModem3gppUssdProxyClass;
typedef struct _MmGdbusModem3gppUssdProxyPrivate MmGdbusModem3gppUssdProxyPrivate;

struct _MmGdbusModem3gppUssdProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  MmGdbusModem3gppUssdProxyPrivate *priv;
};

struct _MmGdbusModem3gppUssdProxyClass
{
  GDBusProxyClass parent_class;
};

GType mm_gdbus_modem3gpp_ussd_proxy_get_type (void) G_GNUC_CONST;

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

void mm_gdbus_modem3gpp_ussd_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModem3gppUssd *mm_gdbus_modem3gpp_ussd_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModem3gppUssd *mm_gdbus_modem3gpp_ussd_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void mm_gdbus_modem3gpp_ussd_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModem3gppUssd *mm_gdbus_modem3gpp_ussd_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModem3gppUssd *mm_gdbus_modem3gpp_ussd_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define MM_GDBUS_TYPE_MODEM3GPP_USSD_SKELETON (mm_gdbus_modem3gpp_ussd_skeleton_get_type ())
#define MM_GDBUS_MODEM3GPP_USSD_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM3GPP_USSD_SKELETON, MmGdbusModem3gppUssdSkeleton))
#define MM_GDBUS_MODEM3GPP_USSD_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM3GPP_USSD_SKELETON, MmGdbusModem3gppUssdSkeletonClass))
#define MM_GDBUS_MODEM3GPP_USSD_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM3GPP_USSD_SKELETON, MmGdbusModem3gppUssdSkeletonClass))
#define MM_GDBUS_IS_MODEM3GPP_USSD_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM3GPP_USSD_SKELETON))
#define MM_GDBUS_IS_MODEM3GPP_USSD_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM3GPP_USSD_SKELETON))

typedef struct _MmGdbusModem3gppUssdSkeleton MmGdbusModem3gppUssdSkeleton;
typedef struct _MmGdbusModem3gppUssdSkeletonClass MmGdbusModem3gppUssdSkeletonClass;
typedef struct _MmGdbusModem3gppUssdSkeletonPrivate MmGdbusModem3gppUssdSkeletonPrivate;

struct _MmGdbusModem3gppUssdSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  MmGdbusModem3gppUssdSkeletonPrivate *priv;
};

struct _MmGdbusModem3gppUssdSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType mm_gdbus_modem3gpp_ussd_skeleton_get_type (void) G_GNUC_CONST;

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

MmGdbusModem3gppUssd *mm_gdbus_modem3gpp_ussd_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.ModemManager1.Modem.Simple */

#define MM_GDBUS_TYPE_MODEM_SIMPLE (mm_gdbus_modem_simple_get_type ())
#define MM_GDBUS_MODEM_SIMPLE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_SIMPLE, MmGdbusModemSimple))
#define MM_GDBUS_IS_MODEM_SIMPLE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_SIMPLE))
#define MM_GDBUS_MODEM_SIMPLE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), MM_GDBUS_TYPE_MODEM_SIMPLE, MmGdbusModemSimpleIface))

struct _MmGdbusModemSimple;
typedef struct _MmGdbusModemSimple MmGdbusModemSimple;
typedef struct _MmGdbusModemSimpleIface MmGdbusModemSimpleIface;

struct _MmGdbusModemSimpleIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_connect) (
    MmGdbusModemSimple *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_properties);

  gboolean (*handle_disconnect) (
    MmGdbusModemSimple *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_bearer);

  gboolean (*handle_get_status) (
    MmGdbusModemSimple *object,
    GDBusMethodInvocation *invocation);

};

GType mm_gdbus_modem_simple_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *mm_gdbus_modem_simple_interface_info (void);
guint mm_gdbus_modem_simple_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void mm_gdbus_modem_simple_complete_connect (
    MmGdbusModemSimple *object,
    GDBusMethodInvocation *invocation,
    const gchar *bearer);

void mm_gdbus_modem_simple_complete_disconnect (
    MmGdbusModemSimple *object,
    GDBusMethodInvocation *invocation);

void mm_gdbus_modem_simple_complete_get_status (
    MmGdbusModemSimple *object,
    GDBusMethodInvocation *invocation,
    GVariant *properties);



/* D-Bus method calls: */
void mm_gdbus_modem_simple_call_connect (
    MmGdbusModemSimple *proxy,
    GVariant *arg_properties,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_simple_call_connect_finish (
    MmGdbusModemSimple *proxy,
    gchar **out_bearer,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_simple_call_connect_sync (
    MmGdbusModemSimple *proxy,
    GVariant *arg_properties,
    gchar **out_bearer,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_simple_call_disconnect (
    MmGdbusModemSimple *proxy,
    const gchar *arg_bearer,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_simple_call_disconnect_finish (
    MmGdbusModemSimple *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_simple_call_disconnect_sync (
    MmGdbusModemSimple *proxy,
    const gchar *arg_bearer,
    GCancellable *cancellable,
    GError **error);

void mm_gdbus_modem_simple_call_get_status (
    MmGdbusModemSimple *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_simple_call_get_status_finish (
    MmGdbusModemSimple *proxy,
    GVariant **out_properties,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_simple_call_get_status_sync (
    MmGdbusModemSimple *proxy,
    GVariant **out_properties,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define MM_GDBUS_TYPE_MODEM_SIMPLE_PROXY (mm_gdbus_modem_simple_proxy_get_type ())
#define MM_GDBUS_MODEM_SIMPLE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_SIMPLE_PROXY, MmGdbusModemSimpleProxy))
#define MM_GDBUS_MODEM_SIMPLE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_SIMPLE_PROXY, MmGdbusModemSimpleProxyClass))
#define MM_GDBUS_MODEM_SIMPLE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_SIMPLE_PROXY, MmGdbusModemSimpleProxyClass))
#define MM_GDBUS_IS_MODEM_SIMPLE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_SIMPLE_PROXY))
#define MM_GDBUS_IS_MODEM_SIMPLE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_SIMPLE_PROXY))

typedef struct _MmGdbusModemSimpleProxy MmGdbusModemSimpleProxy;
typedef struct _MmGdbusModemSimpleProxyClass MmGdbusModemSimpleProxyClass;
typedef struct _MmGdbusModemSimpleProxyPrivate MmGdbusModemSimpleProxyPrivate;

struct _MmGdbusModemSimpleProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  MmGdbusModemSimpleProxyPrivate *priv;
};

struct _MmGdbusModemSimpleProxyClass
{
  GDBusProxyClass parent_class;
};

GType mm_gdbus_modem_simple_proxy_get_type (void) G_GNUC_CONST;

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

void mm_gdbus_modem_simple_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemSimple *mm_gdbus_modem_simple_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemSimple *mm_gdbus_modem_simple_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void mm_gdbus_modem_simple_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemSimple *mm_gdbus_modem_simple_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemSimple *mm_gdbus_modem_simple_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_SIMPLE_SKELETON (mm_gdbus_modem_simple_skeleton_get_type ())
#define MM_GDBUS_MODEM_SIMPLE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_SIMPLE_SKELETON, MmGdbusModemSimpleSkeleton))
#define MM_GDBUS_MODEM_SIMPLE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_SIMPLE_SKELETON, MmGdbusModemSimpleSkeletonClass))
#define MM_GDBUS_MODEM_SIMPLE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_SIMPLE_SKELETON, MmGdbusModemSimpleSkeletonClass))
#define MM_GDBUS_IS_MODEM_SIMPLE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_SIMPLE_SKELETON))
#define MM_GDBUS_IS_MODEM_SIMPLE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_SIMPLE_SKELETON))

typedef struct _MmGdbusModemSimpleSkeleton MmGdbusModemSimpleSkeleton;
typedef struct _MmGdbusModemSimpleSkeletonClass MmGdbusModemSimpleSkeletonClass;
typedef struct _MmGdbusModemSimpleSkeletonPrivate MmGdbusModemSimpleSkeletonPrivate;

struct _MmGdbusModemSimpleSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  MmGdbusModemSimpleSkeletonPrivate *priv;
};

struct _MmGdbusModemSimpleSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType mm_gdbus_modem_simple_skeleton_get_type (void) G_GNUC_CONST;

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

MmGdbusModemSimple *mm_gdbus_modem_simple_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.ModemManager1.Modem.Signal */

#define MM_GDBUS_TYPE_MODEM_SIGNAL (mm_gdbus_modem_signal_get_type ())
#define MM_GDBUS_MODEM_SIGNAL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_SIGNAL, MmGdbusModemSignal))
#define MM_GDBUS_IS_MODEM_SIGNAL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_SIGNAL))
#define MM_GDBUS_MODEM_SIGNAL_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), MM_GDBUS_TYPE_MODEM_SIGNAL, MmGdbusModemSignalIface))

struct _MmGdbusModemSignal;
typedef struct _MmGdbusModemSignal MmGdbusModemSignal;
typedef struct _MmGdbusModemSignalIface MmGdbusModemSignalIface;

struct _MmGdbusModemSignalIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_setup) (
    MmGdbusModemSignal *object,
    GDBusMethodInvocation *invocation,
    guint arg_rate);

  GVariant * (*get_cdma) (MmGdbusModemSignal *object);

  GVariant * (*get_evdo) (MmGdbusModemSignal *object);

  GVariant * (*get_gsm) (MmGdbusModemSignal *object);

  GVariant * (*get_lte) (MmGdbusModemSignal *object);

  guint  (*get_rate) (MmGdbusModemSignal *object);

  GVariant * (*get_umts) (MmGdbusModemSignal *object);

};

GType mm_gdbus_modem_signal_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *mm_gdbus_modem_signal_interface_info (void);
guint mm_gdbus_modem_signal_override_properties (GObjectClass *klass, guint property_id_begin);


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



/* D-Bus method calls: */
void mm_gdbus_modem_signal_call_setup (
    MmGdbusModemSignal *proxy,
    guint arg_rate,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean mm_gdbus_modem_signal_call_setup_finish (
    MmGdbusModemSignal *proxy,
    GAsyncResult *res,
    GError **error);

gboolean mm_gdbus_modem_signal_call_setup_sync (
    MmGdbusModemSignal *proxy,
    guint arg_rate,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint mm_gdbus_modem_signal_get_rate (MmGdbusModemSignal *object);
void mm_gdbus_modem_signal_set_rate (MmGdbusModemSignal *object, guint value);

GVariant *mm_gdbus_modem_signal_get_cdma (MmGdbusModemSignal *object);
GVariant *mm_gdbus_modem_signal_dup_cdma (MmGdbusModemSignal *object);
void mm_gdbus_modem_signal_set_cdma (MmGdbusModemSignal *object, GVariant *value);

GVariant *mm_gdbus_modem_signal_get_evdo (MmGdbusModemSignal *object);
GVariant *mm_gdbus_modem_signal_dup_evdo (MmGdbusModemSignal *object);
void mm_gdbus_modem_signal_set_evdo (MmGdbusModemSignal *object, GVariant *value);

GVariant *mm_gdbus_modem_signal_get_gsm (MmGdbusModemSignal *object);
GVariant *mm_gdbus_modem_signal_dup_gsm (MmGdbusModemSignal *object);
void mm_gdbus_modem_signal_set_gsm (MmGdbusModemSignal *object, GVariant *value);

GVariant *mm_gdbus_modem_signal_get_umts (MmGdbusModemSignal *object);
GVariant *mm_gdbus_modem_signal_dup_umts (MmGdbusModemSignal *object);
void mm_gdbus_modem_signal_set_umts (MmGdbusModemSignal *object, GVariant *value);

GVariant *mm_gdbus_modem_signal_get_lte (MmGdbusModemSignal *object);
GVariant *mm_gdbus_modem_signal_dup_lte (MmGdbusModemSignal *object);
void mm_gdbus_modem_signal_set_lte (MmGdbusModemSignal *object, GVariant *value);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_SIGNAL_PROXY (mm_gdbus_modem_signal_proxy_get_type ())
#define MM_GDBUS_MODEM_SIGNAL_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_SIGNAL_PROXY, MmGdbusModemSignalProxy))
#define MM_GDBUS_MODEM_SIGNAL_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_SIGNAL_PROXY, MmGdbusModemSignalProxyClass))
#define MM_GDBUS_MODEM_SIGNAL_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_SIGNAL_PROXY, MmGdbusModemSignalProxyClass))
#define MM_GDBUS_IS_MODEM_SIGNAL_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_SIGNAL_PROXY))
#define MM_GDBUS_IS_MODEM_SIGNAL_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_SIGNAL_PROXY))

typedef struct _MmGdbusModemSignalProxy MmGdbusModemSignalProxy;
typedef struct _MmGdbusModemSignalProxyClass MmGdbusModemSignalProxyClass;
typedef struct _MmGdbusModemSignalProxyPrivate MmGdbusModemSignalProxyPrivate;

struct _MmGdbusModemSignalProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  MmGdbusModemSignalProxyPrivate *priv;
};

struct _MmGdbusModemSignalProxyClass
{
  GDBusProxyClass parent_class;
};

GType mm_gdbus_modem_signal_proxy_get_type (void) G_GNUC_CONST;

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

void mm_gdbus_modem_signal_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemSignal *mm_gdbus_modem_signal_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemSignal *mm_gdbus_modem_signal_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void mm_gdbus_modem_signal_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
MmGdbusModemSignal *mm_gdbus_modem_signal_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
MmGdbusModemSignal *mm_gdbus_modem_signal_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define MM_GDBUS_TYPE_MODEM_SIGNAL_SKELETON (mm_gdbus_modem_signal_skeleton_get_type ())
#define MM_GDBUS_MODEM_SIGNAL_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_MODEM_SIGNAL_SKELETON, MmGdbusModemSignalSkeleton))
#define MM_GDBUS_MODEM_SIGNAL_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_MODEM_SIGNAL_SKELETON, MmGdbusModemSignalSkeletonClass))
#define MM_GDBUS_MODEM_SIGNAL_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_MODEM_SIGNAL_SKELETON, MmGdbusModemSignalSkeletonClass))
#define MM_GDBUS_IS_MODEM_SIGNAL_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_MODEM_SIGNAL_SKELETON))
#define MM_GDBUS_IS_MODEM_SIGNAL_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_MODEM_SIGNAL_SKELETON))

typedef struct _MmGdbusModemSignalSkeleton MmGdbusModemSignalSkeleton;
typedef struct _MmGdbusModemSignalSkeletonClass MmGdbusModemSignalSkeletonClass;
typedef struct _MmGdbusModemSignalSkeletonPrivate MmGdbusModemSignalSkeletonPrivate;

struct _MmGdbusModemSignalSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  MmGdbusModemSignalSkeletonPrivate *priv;
};

struct _MmGdbusModemSignalSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType mm_gdbus_modem_signal_skeleton_get_type (void) G_GNUC_CONST;

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

MmGdbusModemSignal *mm_gdbus_modem_signal_skeleton_new (void);


/* ---- */

#define MM_GDBUS_TYPE_OBJECT (mm_gdbus_object_get_type ())
#define MM_GDBUS_OBJECT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_OBJECT, MmGdbusObject))
#define MM_GDBUS_IS_OBJECT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_OBJECT))
#define MM_GDBUS_OBJECT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), MM_GDBUS_TYPE_OBJECT, MmGdbusObject))

struct _MmGdbusObject;
typedef struct _MmGdbusObject MmGdbusObject;
typedef struct _MmGdbusObjectIface MmGdbusObjectIface;

struct _MmGdbusObjectIface
{
  GTypeInterface parent_iface;
};

GType mm_gdbus_object_get_type (void) G_GNUC_CONST;

MmGdbusModem *mm_gdbus_object_get_modem (MmGdbusObject *object);
MmGdbusModemMessaging *mm_gdbus_object_get_modem_messaging (MmGdbusObject *object);
MmGdbusModemVoice *mm_gdbus_object_get_modem_voice (MmGdbusObject *object);
MmGdbusModemLocation *mm_gdbus_object_get_modem_location (MmGdbusObject *object);
MmGdbusModemTime *mm_gdbus_object_get_modem_time (MmGdbusObject *object);
MmGdbusModemFirmware *mm_gdbus_object_get_modem_firmware (MmGdbusObject *object);
MmGdbusModemOma *mm_gdbus_object_get_modem_oma (MmGdbusObject *object);
MmGdbusModemCdma *mm_gdbus_object_get_modem_cdma (MmGdbusObject *object);
MmGdbusModem3gpp *mm_gdbus_object_get_modem3gpp (MmGdbusObject *object);
MmGdbusModem3gppUssd *mm_gdbus_object_get_modem3gpp_ussd (MmGdbusObject *object);
MmGdbusModemSimple *mm_gdbus_object_get_modem_simple (MmGdbusObject *object);
MmGdbusModemSignal *mm_gdbus_object_get_modem_signal (MmGdbusObject *object);
MmGdbusModem *mm_gdbus_object_peek_modem (MmGdbusObject *object);
MmGdbusModemMessaging *mm_gdbus_object_peek_modem_messaging (MmGdbusObject *object);
MmGdbusModemVoice *mm_gdbus_object_peek_modem_voice (MmGdbusObject *object);
MmGdbusModemLocation *mm_gdbus_object_peek_modem_location (MmGdbusObject *object);
MmGdbusModemTime *mm_gdbus_object_peek_modem_time (MmGdbusObject *object);
MmGdbusModemFirmware *mm_gdbus_object_peek_modem_firmware (MmGdbusObject *object);
MmGdbusModemOma *mm_gdbus_object_peek_modem_oma (MmGdbusObject *object);
MmGdbusModemCdma *mm_gdbus_object_peek_modem_cdma (MmGdbusObject *object);
MmGdbusModem3gpp *mm_gdbus_object_peek_modem3gpp (MmGdbusObject *object);
MmGdbusModem3gppUssd *mm_gdbus_object_peek_modem3gpp_ussd (MmGdbusObject *object);
MmGdbusModemSimple *mm_gdbus_object_peek_modem_simple (MmGdbusObject *object);
MmGdbusModemSignal *mm_gdbus_object_peek_modem_signal (MmGdbusObject *object);

#define MM_GDBUS_TYPE_OBJECT_PROXY (mm_gdbus_object_proxy_get_type ())
#define MM_GDBUS_OBJECT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_OBJECT_PROXY, MmGdbusObjectProxy))
#define MM_GDBUS_OBJECT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_OBJECT_PROXY, MmGdbusObjectProxyClass))
#define MM_GDBUS_OBJECT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_OBJECT_PROXY, MmGdbusObjectProxyClass))
#define MM_GDBUS_IS_OBJECT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_OBJECT_PROXY))
#define MM_GDBUS_IS_OBJECT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_OBJECT_PROXY))

typedef struct _MmGdbusObjectProxy MmGdbusObjectProxy;
typedef struct _MmGdbusObjectProxyClass MmGdbusObjectProxyClass;
typedef struct _MmGdbusObjectProxyPrivate MmGdbusObjectProxyPrivate;

struct _MmGdbusObjectProxy
{
  /*< private >*/
  GDBusObjectProxy parent_instance;
  MmGdbusObjectProxyPrivate *priv;
};

struct _MmGdbusObjectProxyClass
{
  GDBusObjectProxyClass parent_class;
};

GType mm_gdbus_object_proxy_get_type (void) G_GNUC_CONST;

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

MmGdbusObjectProxy *mm_gdbus_object_proxy_new (GDBusConnection *connection, const gchar *object_path);

#define MM_GDBUS_TYPE_OBJECT_SKELETON (mm_gdbus_object_skeleton_get_type ())
#define MM_GDBUS_OBJECT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_OBJECT_SKELETON, MmGdbusObjectSkeleton))
#define MM_GDBUS_OBJECT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_OBJECT_SKELETON, MmGdbusObjectSkeletonClass))
#define MM_GDBUS_OBJECT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_OBJECT_SKELETON, MmGdbusObjectSkeletonClass))
#define MM_GDBUS_IS_OBJECT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_OBJECT_SKELETON))
#define MM_GDBUS_IS_OBJECT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_OBJECT_SKELETON))

typedef struct _MmGdbusObjectSkeleton MmGdbusObjectSkeleton;
typedef struct _MmGdbusObjectSkeletonClass MmGdbusObjectSkeletonClass;
typedef struct _MmGdbusObjectSkeletonPrivate MmGdbusObjectSkeletonPrivate;

struct _MmGdbusObjectSkeleton
{
  /*< private >*/
  GDBusObjectSkeleton parent_instance;
  MmGdbusObjectSkeletonPrivate *priv;
};

struct _MmGdbusObjectSkeletonClass
{
  GDBusObjectSkeletonClass parent_class;
};

GType mm_gdbus_object_skeleton_get_type (void) G_GNUC_CONST;

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

MmGdbusObjectSkeleton *mm_gdbus_object_skeleton_new (const gchar *object_path);
void mm_gdbus_object_skeleton_set_modem (MmGdbusObjectSkeleton *object, MmGdbusModem *interface_);
void mm_gdbus_object_skeleton_set_modem_messaging (MmGdbusObjectSkeleton *object, MmGdbusModemMessaging *interface_);
void mm_gdbus_object_skeleton_set_modem_voice (MmGdbusObjectSkeleton *object, MmGdbusModemVoice *interface_);
void mm_gdbus_object_skeleton_set_modem_location (MmGdbusObjectSkeleton *object, MmGdbusModemLocation *interface_);
void mm_gdbus_object_skeleton_set_modem_time (MmGdbusObjectSkeleton *object, MmGdbusModemTime *interface_);
void mm_gdbus_object_skeleton_set_modem_firmware (MmGdbusObjectSkeleton *object, MmGdbusModemFirmware *interface_);
void mm_gdbus_object_skeleton_set_modem_oma (MmGdbusObjectSkeleton *object, MmGdbusModemOma *interface_);
void mm_gdbus_object_skeleton_set_modem_cdma (MmGdbusObjectSkeleton *object, MmGdbusModemCdma *interface_);
void mm_gdbus_object_skeleton_set_modem3gpp (MmGdbusObjectSkeleton *object, MmGdbusModem3gpp *interface_);
void mm_gdbus_object_skeleton_set_modem3gpp_ussd (MmGdbusObjectSkeleton *object, MmGdbusModem3gppUssd *interface_);
void mm_gdbus_object_skeleton_set_modem_simple (MmGdbusObjectSkeleton *object, MmGdbusModemSimple *interface_);
void mm_gdbus_object_skeleton_set_modem_signal (MmGdbusObjectSkeleton *object, MmGdbusModemSignal *interface_);

/* ---- */

#define MM_GDBUS_TYPE_OBJECT_MANAGER_CLIENT (mm_gdbus_object_manager_client_get_type ())
#define MM_GDBUS_OBJECT_MANAGER_CLIENT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), MM_GDBUS_TYPE_OBJECT_MANAGER_CLIENT, MmGdbusObjectManagerClient))
#define MM_GDBUS_OBJECT_MANAGER_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), MM_GDBUS_TYPE_OBJECT_MANAGER_CLIENT, MmGdbusObjectManagerClientClass))
#define MM_GDBUS_OBJECT_MANAGER_CLIENT_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), MM_GDBUS_TYPE_OBJECT_MANAGER_CLIENT, MmGdbusObjectManagerClientClass))
#define MM_GDBUS_IS_OBJECT_MANAGER_CLIENT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), MM_GDBUS_TYPE_OBJECT_MANAGER_CLIENT))
#define MM_GDBUS_IS_OBJECT_MANAGER_CLIENT_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), MM_GDBUS_TYPE_OBJECT_MANAGER_CLIENT))

typedef struct _MmGdbusObjectManagerClient MmGdbusObjectManagerClient;
typedef struct _MmGdbusObjectManagerClientClass MmGdbusObjectManagerClientClass;
typedef struct _MmGdbusObjectManagerClientPrivate MmGdbusObjectManagerClientPrivate;

struct _MmGdbusObjectManagerClient
{
  /*< private >*/
  GDBusObjectManagerClient parent_instance;
  MmGdbusObjectManagerClientPrivate *priv;
};

struct _MmGdbusObjectManagerClientClass
{
  GDBusObjectManagerClientClass parent_class;
};

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

GType mm_gdbus_object_manager_client_get_type (void) G_GNUC_CONST;

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

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

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