/* dbus.c generated by valac 0.16.1, the Vala compiler
 * generated from dbus.vala, do not modify */

/*
 * Copyright (C) 2009-2012 Michael 'Mickey' Lauer <mlauer@vanille-media.de>
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.

 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.

 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
 *
 */

#include <glib.h>
#include <glib-object.h>
#include <stdlib.h>
#include <string.h>
#include <gio/gio.h>
#include <fsobasics.h>
#include <gobject/gvaluecollector.h>


#define DBUS_SERVICE_TYPE_IINTROSPECTABLE (dbus_service_iintrospectable_get_type ())
#define DBUS_SERVICE_IINTROSPECTABLE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_SERVICE_TYPE_IINTROSPECTABLE, DBusServiceIIntrospectable))
#define DBUS_SERVICE_IS_IINTROSPECTABLE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_SERVICE_TYPE_IINTROSPECTABLE))
#define DBUS_SERVICE_IINTROSPECTABLE_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), DBUS_SERVICE_TYPE_IINTROSPECTABLE, DBusServiceIIntrospectableIface))

typedef struct _DBusServiceIIntrospectable DBusServiceIIntrospectable;
typedef struct _DBusServiceIIntrospectableIface DBusServiceIIntrospectableIface;

#define DBUS_SERVICE_TYPE_IINTROSPECTABLE_PROXY (dbus_service_iintrospectable_proxy_get_type ())
typedef GDBusProxy DBusServiceIIntrospectableProxy;
typedef GDBusProxyClass DBusServiceIIntrospectableProxyClass;
#define _g_free0(var) (var = (g_free (var), NULL))

#define DBUS_SERVICE_TYPE_IPROPERTIES (dbus_service_iproperties_get_type ())
#define DBUS_SERVICE_IPROPERTIES(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_SERVICE_TYPE_IPROPERTIES, DBusServiceIProperties))
#define DBUS_SERVICE_IS_IPROPERTIES(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_SERVICE_TYPE_IPROPERTIES))
#define DBUS_SERVICE_IPROPERTIES_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), DBUS_SERVICE_TYPE_IPROPERTIES, DBusServiceIPropertiesIface))

typedef struct _DBusServiceIProperties DBusServiceIProperties;
typedef struct _DBusServiceIPropertiesIface DBusServiceIPropertiesIface;

#define DBUS_SERVICE_TYPE_IPROPERTIES_PROXY (dbus_service_iproperties_proxy_get_type ())
typedef GDBusProxy DBusServiceIPropertiesProxy;
typedef GDBusProxyClass DBusServiceIPropertiesProxyClass;
#define _g_variant_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_unref (var), NULL)))
#define _g_hash_table_unref0(var) ((var == NULL) ? NULL : (var = (g_hash_table_unref (var), NULL)))

#define DBUS_SERVICE_TYPE_IPEER (dbus_service_ipeer_get_type ())
#define DBUS_SERVICE_IPEER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_SERVICE_TYPE_IPEER, DBusServiceIPeer))
#define DBUS_SERVICE_IS_IPEER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_SERVICE_TYPE_IPEER))
#define DBUS_SERVICE_IPEER_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), DBUS_SERVICE_TYPE_IPEER, DBusServiceIPeerIface))

typedef struct _DBusServiceIPeer DBusServiceIPeer;
typedef struct _DBusServiceIPeerIface DBusServiceIPeerIface;

#define DBUS_SERVICE_TYPE_IPEER_PROXY (dbus_service_ipeer_proxy_get_type ())
typedef GDBusProxy DBusServiceIPeerProxy;
typedef GDBusProxyClass DBusServiceIPeerProxyClass;

#define DBUS_SERVICE_TYPE_ID_BUS (dbus_service_id_bus_get_type ())
#define DBUS_SERVICE_ID_BUS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_SERVICE_TYPE_ID_BUS, DBusServiceIDBus))
#define DBUS_SERVICE_IS_ID_BUS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_SERVICE_TYPE_ID_BUS))
#define DBUS_SERVICE_ID_BUS_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), DBUS_SERVICE_TYPE_ID_BUS, DBusServiceIDBusIface))

typedef struct _DBusServiceIDBus DBusServiceIDBus;
typedef struct _DBusServiceIDBusIface DBusServiceIDBusIface;

#define DBUS_SERVICE_TYPE_ID_BUS_PROXY (dbus_service_id_bus_proxy_get_type ())
typedef GDBusProxy DBusServiceIDBusProxy;
typedef GDBusProxyClass DBusServiceIDBusProxyClass;

#define DBUS_SERVICE_TYPE_ID_BUS_SYNC (dbus_service_id_bus_sync_get_type ())
#define DBUS_SERVICE_ID_BUS_SYNC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUS_SERVICE_TYPE_ID_BUS_SYNC, DBusServiceIDBusSync))
#define DBUS_SERVICE_IS_ID_BUS_SYNC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUS_SERVICE_TYPE_ID_BUS_SYNC))
#define DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), DBUS_SERVICE_TYPE_ID_BUS_SYNC, DBusServiceIDBusSyncIface))

typedef struct _DBusServiceIDBusSync DBusServiceIDBusSync;
typedef struct _DBusServiceIDBusSyncIface DBusServiceIDBusSyncIface;

#define DBUS_SERVICE_TYPE_ID_BUS_SYNC_PROXY (dbus_service_id_bus_sync_proxy_get_type ())
typedef GDBusProxy DBusServiceIDBusSyncProxy;
typedef GDBusProxyClass DBusServiceIDBusSyncProxyClass;
typedef struct _DBusFuncDelegateHolder DBusFuncDelegateHolder;

#define FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE (fso_framework_dbus_service_notifier_delegate_get_type ())
#define FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE, FsoFrameworkDBusServiceNotifierDelegate))
#define FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_DELEGATE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE, FsoFrameworkDBusServiceNotifierDelegateClass))
#define FSO_FRAMEWORK_IS_DBUS_SERVICE_NOTIFIER_DELEGATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE))
#define FSO_FRAMEWORK_IS_DBUS_SERVICE_NOTIFIER_DELEGATE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE))
#define FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_DELEGATE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE, FsoFrameworkDBusServiceNotifierDelegateClass))

typedef struct _FsoFrameworkDBusServiceNotifierDelegate FsoFrameworkDBusServiceNotifierDelegate;
typedef struct _FsoFrameworkDBusServiceNotifierDelegateClass FsoFrameworkDBusServiceNotifierDelegateClass;
typedef struct _FsoFrameworkDBusServiceNotifierDelegatePrivate FsoFrameworkDBusServiceNotifierDelegatePrivate;
#define _t_destroy_func0(var) (((var == NULL) || (t_destroy_func == NULL)) ? NULL : (var = (t_destroy_func (var), NULL)))
typedef struct _FsoFrameworkParamSpecDBusServiceNotifierDelegate FsoFrameworkParamSpecDBusServiceNotifierDelegate;

#define FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER (fso_framework_dbus_service_notifier_get_type ())
#define FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER, FsoFrameworkDBusServiceNotifier))
#define FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER, FsoFrameworkDBusServiceNotifierClass))
#define FSO_FRAMEWORK_IS_DBUS_SERVICE_NOTIFIER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER))
#define FSO_FRAMEWORK_IS_DBUS_SERVICE_NOTIFIER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER))
#define FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER, FsoFrameworkDBusServiceNotifierClass))

typedef struct _FsoFrameworkDBusServiceNotifier FsoFrameworkDBusServiceNotifier;
typedef struct _FsoFrameworkDBusServiceNotifierClass FsoFrameworkDBusServiceNotifierClass;
typedef struct _FsoFrameworkDBusServiceNotifierPrivate FsoFrameworkDBusServiceNotifierPrivate;
#define _g_object_unref0(var) ((var == NULL) ? NULL : (var = (g_object_unref (var), NULL)))
#define _g_error_free0(var) ((var == NULL) ? NULL : (var = (g_error_free (var), NULL)))
#define __g_list_free__dbus_func_delegate_holder_free0_0(var) ((var == NULL) ? NULL : (var = (_g_list_free__dbus_func_delegate_holder_free0_ (var), NULL)))

struct _DBusServiceIIntrospectableIface {
	GTypeInterface parent_iface;
	void (*Introspect) (DBusServiceIIntrospectable* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
	gchar* (*Introspect_finish) (DBusServiceIIntrospectable* self, GAsyncResult* _res_, GError** error);
};

struct _DBusServiceIPropertiesIface {
	GTypeInterface parent_iface;
	void (*Get) (DBusServiceIProperties* self, const gchar* iface, const gchar* prop, GAsyncReadyCallback _callback_, gpointer _user_data_);
	GVariant* (*Get_finish) (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error);
	void (*Set) (DBusServiceIProperties* self, const gchar* iface, const gchar* prop, GVariant* val, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*Set_finish) (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error);
	void (*GetAll) (DBusServiceIProperties* self, const gchar* iface, GAsyncReadyCallback _callback_, gpointer _user_data_);
	GHashTable* (*GetAll_finish) (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error);
};

struct _DBusServiceIPeerIface {
	GTypeInterface parent_iface;
	void (*Ping) (DBusServiceIPeer* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*Ping_finish) (DBusServiceIPeer* self, GAsyncResult* _res_, GError** error);
};

struct _DBusServiceIDBusIface {
	GTypeInterface parent_iface;
	void (*AddMatch) (DBusServiceIDBus* self, const gchar* match, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*AddMatch_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
	void (*GetAdtAuditSessionData) (DBusServiceIDBus* self, const gchar* type, GAsyncReadyCallback _callback_, gpointer _user_data_);
	guint8* (*GetAdtAuditSessionData_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
	void (*GetConnectionSELinuxSecurityContext) (DBusServiceIDBus* self, const gchar* type, GAsyncReadyCallback _callback_, gpointer _user_data_);
	guint8* (*GetConnectionSELinuxSecurityContext_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
	void (*GetConnectionUnixProcessID) (DBusServiceIDBus* self, const gchar* conn, GAsyncReadyCallback _callback_, gpointer _user_data_);
	guint32 (*GetConnectionUnixProcessID_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
	void (*GetConnectionUnixUser) (DBusServiceIDBus* self, const gchar* conn, GAsyncReadyCallback _callback_, gpointer _user_data_);
	guint32 (*GetConnectionUnixUser_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
	void (*GetId) (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
	gchar* (*GetId_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
	void (*GetNameOwner) (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_);
	gchar* (*GetNameOwner_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
	void (*Hello) (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
	gchar* (*Hello_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
	void (*ListActivatableNames) (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
	gchar** (*ListActivatableNames_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
	void (*ListNames) (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
	gchar** (*ListNames_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
	void (*ListQueuedOwners) (DBusServiceIDBus* self, const gchar* None, GAsyncReadyCallback _callback_, gpointer _user_data_);
	gchar** (*ListQueuedOwners_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
	void (*NameHasOwner) (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_);
	gboolean (*NameHasOwner_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
	void (*ReleaseName) (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_);
	guint32 (*ReleaseName_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
	void (*ReloadConfig) (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*ReloadConfig_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
	void (*RemoveMatch) (DBusServiceIDBus* self, const gchar* match, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*RemoveMatch_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
	void (*RequestName) (DBusServiceIDBus* self, const gchar* name, guint32 flags, GAsyncReadyCallback _callback_, gpointer _user_data_);
	guint32 (*RequestName_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
	void (*StartServiceByName) (DBusServiceIDBus* self, const gchar* name, guint32 flags, GAsyncReadyCallback _callback_, gpointer _user_data_);
	guint32 (*StartServiceByName_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
	void (*UpdateActivationEnvironment) (DBusServiceIDBus* self, GHashTable* environment, GAsyncReadyCallback _callback_, gpointer _user_data_);
	void (*UpdateActivationEnvironment_finish) (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
};

struct _DBusServiceIDBusSyncIface {
	GTypeInterface parent_iface;
	void (*AddMatch) (DBusServiceIDBusSync* self, const gchar* match, GError** error);
	guint8* (*GetAdtAuditSessionData) (DBusServiceIDBusSync* self, const gchar* type, int* result_length1, GError** error);
	guint8* (*GetConnectionSELinuxSecurityContext) (DBusServiceIDBusSync* self, const gchar* type, int* result_length1, GError** error);
	guint32 (*GetConnectionUnixProcessID) (DBusServiceIDBusSync* self, const gchar* conn, GError** error);
	guint32 (*GetConnectionUnixUser) (DBusServiceIDBusSync* self, const gchar* conn, GError** error);
	gchar* (*GetId) (DBusServiceIDBusSync* self, GError** error);
	gchar* (*GetNameOwner) (DBusServiceIDBusSync* self, const gchar* name, GError** error);
	gchar* (*Hello) (DBusServiceIDBusSync* self, GError** error);
	gchar** (*ListActivatableNames) (DBusServiceIDBusSync* self, int* result_length1, GError** error);
	gchar** (*ListNames) (DBusServiceIDBusSync* self, int* result_length1, GError** error);
	gchar** (*ListQueuedOwners) (DBusServiceIDBusSync* self, const gchar* None, int* result_length1, GError** error);
	gboolean (*NameHasOwner) (DBusServiceIDBusSync* self, const gchar* name, GError** error);
	guint32 (*ReleaseName) (DBusServiceIDBusSync* self, const gchar* name, GError** error);
	void (*ReloadConfig) (DBusServiceIDBusSync* self, GError** error);
	void (*RemoveMatch) (DBusServiceIDBusSync* self, const gchar* match, GError** error);
	guint32 (*RequestName) (DBusServiceIDBusSync* self, const gchar* name, guint32 flags, GError** error);
	guint32 (*StartServiceByName) (DBusServiceIDBusSync* self, const gchar* name, guint32 flags, GError** error);
	void (*UpdateActivationEnvironment) (DBusServiceIDBusSync* self, GHashTable* environment, GError** error);
};

typedef void (*FsoFrameworkDBusServiceEventFunc) (const gchar* busname, void* user_data);
struct _DBusFuncDelegateHolder {
	FsoFrameworkDBusServiceEventFunc func;
	gpointer func_target;
	GDestroyNotify func_target_destroy_notify;
};

struct _FsoFrameworkDBusServiceNotifierDelegate {
	GTypeInstance parent_instance;
	volatile int ref_count;
	FsoFrameworkDBusServiceNotifierDelegatePrivate * priv;
};

struct _FsoFrameworkDBusServiceNotifierDelegateClass {
	GTypeClass parent_class;
	void (*finalize) (FsoFrameworkDBusServiceNotifierDelegate *self);
};

struct _FsoFrameworkDBusServiceNotifierDelegatePrivate {
	GType t_type;
	GBoxedCopyFunc t_dup_func;
	GDestroyNotify t_destroy_func;
	gpointer t;
};

struct _FsoFrameworkParamSpecDBusServiceNotifierDelegate {
	GParamSpec parent_instance;
};

struct _FsoFrameworkDBusServiceNotifier {
	FsoFrameworkAbstractObject parent_instance;
	FsoFrameworkDBusServiceNotifierPrivate * priv;
};

struct _FsoFrameworkDBusServiceNotifierClass {
	FsoFrameworkAbstractObjectClass parent_class;
};

struct _FsoFrameworkDBusServiceNotifierPrivate {
	DBusServiceIDBus* obj;
	GHashTable* appear;
	GHashTable* disappear;
};


static gpointer fso_framework_dbus_service_notifier_delegate_parent_class = NULL;
static gpointer fso_framework_dbus_service_notifier_parent_class = NULL;

#define DBUS_SERVICE_DBUS_SERVICE_DBUS "org.freedesktop.DBus"
#define DBUS_SERVICE_DBUS_PATH_DBUS "/org/freedesktop/DBus"
#define DBUS_SERVICE_DBUS_INTERFACE_INTROSPECTABLE "org.freedesktop.DBus.Introspectable"
#define DBUS_SERVICE_DBUS_INTERFACE_PROPERTIES "org.freedesktop.DBus.Properties"
#define DBUS_SERVICE_DBUS_INTERFACE_PEER "org.freedesktop.DBus.Peer"
#define DBUS_SERVICE_DBUS_INTERFACE_DBUS "org.freedesktop.DBus"
GType dbus_service_iintrospectable_proxy_get_type (void) G_GNUC_CONST;
guint dbus_service_iintrospectable_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
GType dbus_service_iintrospectable_get_type (void) G_GNUC_CONST;
void dbus_service_iintrospectable_Introspect (DBusServiceIIntrospectable* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
gchar* dbus_service_iintrospectable_Introspect_finish (DBusServiceIIntrospectable* self, GAsyncResult* _res_, GError** error);
static void dbus_service_iintrospectable_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters);
static void _vala_g_async_ready_callback (GObject *source_object, GAsyncResult *res, void *user_data);
static void dbus_service_iintrospectable_proxy_Introspect_async (DBusServiceIIntrospectable* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gchar* dbus_service_iintrospectable_proxy_Introspect_finish (DBusServiceIIntrospectable* self, GAsyncResult* _res_, GError** error);
static void dbus_service_iintrospectable_proxy_dbus_service_iintrospectable_interface_init (DBusServiceIIntrospectableIface* iface);
static void _dbus_dbus_service_iintrospectable_Introspect (DBusServiceIIntrospectable* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_iintrospectable_Introspect_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void dbus_service_iintrospectable_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data);
static GVariant* dbus_service_iintrospectable_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data);
static gboolean dbus_service_iintrospectable_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data);
static void _dbus_service_iintrospectable_unregister_object (gpointer user_data);
GType dbus_service_iproperties_proxy_get_type (void) G_GNUC_CONST;
guint dbus_service_iproperties_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
GType dbus_service_iproperties_get_type (void) G_GNUC_CONST;
void dbus_service_iproperties_Get (DBusServiceIProperties* self, const gchar* iface, const gchar* prop, GAsyncReadyCallback _callback_, gpointer _user_data_);
GVariant* dbus_service_iproperties_Get_finish (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error);
void dbus_service_iproperties_Set (DBusServiceIProperties* self, const gchar* iface, const gchar* prop, GVariant* val, GAsyncReadyCallback _callback_, gpointer _user_data_);
void dbus_service_iproperties_Set_finish (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error);
void dbus_service_iproperties_GetAll (DBusServiceIProperties* self, const gchar* iface, GAsyncReadyCallback _callback_, gpointer _user_data_);
GHashTable* dbus_service_iproperties_GetAll_finish (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error);
static void dbus_service_iproperties_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters);
static void dbus_service_iproperties_proxy_Get_async (DBusServiceIProperties* self, const gchar* iface, const gchar* prop, GAsyncReadyCallback _callback_, gpointer _user_data_);
static GVariant* dbus_service_iproperties_proxy_Get_finish (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error);
static void dbus_service_iproperties_proxy_Set_async (DBusServiceIProperties* self, const gchar* iface, const gchar* prop, GVariant* val, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void dbus_service_iproperties_proxy_Set_finish (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error);
static void dbus_service_iproperties_proxy_GetAll_async (DBusServiceIProperties* self, const gchar* iface, GAsyncReadyCallback _callback_, gpointer _user_data_);
static GHashTable* dbus_service_iproperties_proxy_GetAll_finish (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error);
static void dbus_service_iproperties_proxy_dbus_service_iproperties_interface_init (DBusServiceIPropertiesIface* iface);
static void _dbus_dbus_service_iproperties_Get (DBusServiceIProperties* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_iproperties_Get_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_iproperties_Set (DBusServiceIProperties* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_iproperties_Set_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_iproperties_GetAll (DBusServiceIProperties* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_iproperties_GetAll_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void dbus_service_iproperties_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data);
static GVariant* dbus_service_iproperties_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data);
static gboolean dbus_service_iproperties_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data);
static void _dbus_service_iproperties_unregister_object (gpointer user_data);
GType dbus_service_ipeer_proxy_get_type (void) G_GNUC_CONST;
guint dbus_service_ipeer_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
GType dbus_service_ipeer_get_type (void) G_GNUC_CONST;
void dbus_service_ipeer_Ping (DBusServiceIPeer* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
void dbus_service_ipeer_Ping_finish (DBusServiceIPeer* self, GAsyncResult* _res_, GError** error);
static void dbus_service_ipeer_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters);
static void dbus_service_ipeer_proxy_Ping_async (DBusServiceIPeer* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void dbus_service_ipeer_proxy_Ping_finish (DBusServiceIPeer* self, GAsyncResult* _res_, GError** error);
static void dbus_service_ipeer_proxy_dbus_service_ipeer_interface_init (DBusServiceIPeerIface* iface);
static void _dbus_dbus_service_ipeer_Ping (DBusServiceIPeer* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_ipeer_Ping_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void dbus_service_ipeer_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data);
static GVariant* dbus_service_ipeer_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data);
static gboolean dbus_service_ipeer_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data);
static void _dbus_service_ipeer_unregister_object (gpointer user_data);
GType dbus_service_id_bus_proxy_get_type (void) G_GNUC_CONST;
guint dbus_service_id_bus_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
GType dbus_service_id_bus_get_type (void) G_GNUC_CONST;
void dbus_service_id_bus_AddMatch (DBusServiceIDBus* self, const gchar* match, GAsyncReadyCallback _callback_, gpointer _user_data_);
void dbus_service_id_bus_AddMatch_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
void dbus_service_id_bus_GetAdtAuditSessionData (DBusServiceIDBus* self, const gchar* type, GAsyncReadyCallback _callback_, gpointer _user_data_);
guint8* dbus_service_id_bus_GetAdtAuditSessionData_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
void dbus_service_id_bus_GetConnectionSELinuxSecurityContext (DBusServiceIDBus* self, const gchar* type, GAsyncReadyCallback _callback_, gpointer _user_data_);
guint8* dbus_service_id_bus_GetConnectionSELinuxSecurityContext_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
void dbus_service_id_bus_GetConnectionUnixProcessID (DBusServiceIDBus* self, const gchar* conn, GAsyncReadyCallback _callback_, gpointer _user_data_);
guint32 dbus_service_id_bus_GetConnectionUnixProcessID_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
void dbus_service_id_bus_GetConnectionUnixUser (DBusServiceIDBus* self, const gchar* conn, GAsyncReadyCallback _callback_, gpointer _user_data_);
guint32 dbus_service_id_bus_GetConnectionUnixUser_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
void dbus_service_id_bus_GetId (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
gchar* dbus_service_id_bus_GetId_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
void dbus_service_id_bus_GetNameOwner (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_);
gchar* dbus_service_id_bus_GetNameOwner_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
void dbus_service_id_bus_Hello (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
gchar* dbus_service_id_bus_Hello_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
void dbus_service_id_bus_ListActivatableNames (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
gchar** dbus_service_id_bus_ListActivatableNames_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
void dbus_service_id_bus_ListNames (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
gchar** dbus_service_id_bus_ListNames_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
void dbus_service_id_bus_ListQueuedOwners (DBusServiceIDBus* self, const gchar* None, GAsyncReadyCallback _callback_, gpointer _user_data_);
gchar** dbus_service_id_bus_ListQueuedOwners_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
void dbus_service_id_bus_NameHasOwner (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_);
gboolean dbus_service_id_bus_NameHasOwner_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
void dbus_service_id_bus_ReleaseName (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_);
guint32 dbus_service_id_bus_ReleaseName_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
void dbus_service_id_bus_ReloadConfig (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
void dbus_service_id_bus_ReloadConfig_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
void dbus_service_id_bus_RemoveMatch (DBusServiceIDBus* self, const gchar* match, GAsyncReadyCallback _callback_, gpointer _user_data_);
void dbus_service_id_bus_RemoveMatch_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
void dbus_service_id_bus_RequestName (DBusServiceIDBus* self, const gchar* name, guint32 flags, GAsyncReadyCallback _callback_, gpointer _user_data_);
guint32 dbus_service_id_bus_RequestName_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
void dbus_service_id_bus_StartServiceByName (DBusServiceIDBus* self, const gchar* name, guint32 flags, GAsyncReadyCallback _callback_, gpointer _user_data_);
guint32 dbus_service_id_bus_StartServiceByName_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
void dbus_service_id_bus_UpdateActivationEnvironment (DBusServiceIDBus* self, GHashTable* environment, GAsyncReadyCallback _callback_, gpointer _user_data_);
void dbus_service_id_bus_UpdateActivationEnvironment_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void g_cclosure_user_marshal_VOID__STRING_STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data);
static void dbus_service_id_bus_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters);
static void _dbus_handle_dbus_service_id_bus_name_acquired (DBusServiceIDBus* self, GVariant* parameters);
static void _dbus_handle_dbus_service_id_bus_name_lost (DBusServiceIDBus* self, GVariant* parameters);
static void _dbus_handle_dbus_service_id_bus_name_owner_changed (DBusServiceIDBus* self, GVariant* parameters);
static void dbus_service_id_bus_proxy_AddMatch_async (DBusServiceIDBus* self, const gchar* match, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void dbus_service_id_bus_proxy_AddMatch_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void dbus_service_id_bus_proxy_GetAdtAuditSessionData_async (DBusServiceIDBus* self, const gchar* type, GAsyncReadyCallback _callback_, gpointer _user_data_);
static guint8* dbus_service_id_bus_proxy_GetAdtAuditSessionData_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
static void dbus_service_id_bus_proxy_GetConnectionSELinuxSecurityContext_async (DBusServiceIDBus* self, const gchar* type, GAsyncReadyCallback _callback_, gpointer _user_data_);
static guint8* dbus_service_id_bus_proxy_GetConnectionSELinuxSecurityContext_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
static void dbus_service_id_bus_proxy_GetConnectionUnixProcessID_async (DBusServiceIDBus* self, const gchar* conn, GAsyncReadyCallback _callback_, gpointer _user_data_);
static guint32 dbus_service_id_bus_proxy_GetConnectionUnixProcessID_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void dbus_service_id_bus_proxy_GetConnectionUnixUser_async (DBusServiceIDBus* self, const gchar* conn, GAsyncReadyCallback _callback_, gpointer _user_data_);
static guint32 dbus_service_id_bus_proxy_GetConnectionUnixUser_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void dbus_service_id_bus_proxy_GetId_async (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gchar* dbus_service_id_bus_proxy_GetId_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void dbus_service_id_bus_proxy_GetNameOwner_async (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gchar* dbus_service_id_bus_proxy_GetNameOwner_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void dbus_service_id_bus_proxy_Hello_async (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gchar* dbus_service_id_bus_proxy_Hello_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void dbus_service_id_bus_proxy_ListActivatableNames_async (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gchar** dbus_service_id_bus_proxy_ListActivatableNames_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
static void dbus_service_id_bus_proxy_ListNames_async (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gchar** dbus_service_id_bus_proxy_ListNames_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
static void dbus_service_id_bus_proxy_ListQueuedOwners_async (DBusServiceIDBus* self, const gchar* None, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gchar** dbus_service_id_bus_proxy_ListQueuedOwners_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error);
static void dbus_service_id_bus_proxy_NameHasOwner_async (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_);
static gboolean dbus_service_id_bus_proxy_NameHasOwner_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void dbus_service_id_bus_proxy_ReleaseName_async (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_);
static guint32 dbus_service_id_bus_proxy_ReleaseName_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void dbus_service_id_bus_proxy_ReloadConfig_async (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void dbus_service_id_bus_proxy_ReloadConfig_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void dbus_service_id_bus_proxy_RemoveMatch_async (DBusServiceIDBus* self, const gchar* match, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void dbus_service_id_bus_proxy_RemoveMatch_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void dbus_service_id_bus_proxy_RequestName_async (DBusServiceIDBus* self, const gchar* name, guint32 flags, GAsyncReadyCallback _callback_, gpointer _user_data_);
static guint32 dbus_service_id_bus_proxy_RequestName_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void dbus_service_id_bus_proxy_StartServiceByName_async (DBusServiceIDBus* self, const gchar* name, guint32 flags, GAsyncReadyCallback _callback_, gpointer _user_data_);
static guint32 dbus_service_id_bus_proxy_StartServiceByName_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void dbus_service_id_bus_proxy_UpdateActivationEnvironment_async (DBusServiceIDBus* self, GHashTable* environment, GAsyncReadyCallback _callback_, gpointer _user_data_);
static void dbus_service_id_bus_proxy_UpdateActivationEnvironment_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error);
static void dbus_service_id_bus_proxy_dbus_service_id_bus_interface_init (DBusServiceIDBusIface* iface);
static void _dbus_dbus_service_id_bus_AddMatch (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_AddMatch_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_GetAdtAuditSessionData (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_GetAdtAuditSessionData_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_GetConnectionSELinuxSecurityContext (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_GetConnectionSELinuxSecurityContext_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_GetConnectionUnixProcessID (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_GetConnectionUnixProcessID_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_GetConnectionUnixUser (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_GetConnectionUnixUser_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_GetId (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_GetId_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_GetNameOwner (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_GetNameOwner_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_Hello (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_Hello_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_ListActivatableNames (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_ListActivatableNames_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_ListNames (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_ListNames_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_ListQueuedOwners (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_ListQueuedOwners_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_NameHasOwner (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_NameHasOwner_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_ReleaseName (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_ReleaseName_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_ReloadConfig (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_ReloadConfig_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_RemoveMatch (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_RemoveMatch_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_RequestName (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_RequestName_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_StartServiceByName (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_StartServiceByName_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void _dbus_dbus_service_id_bus_UpdateActivationEnvironment (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_UpdateActivationEnvironment_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_);
static void dbus_service_id_bus_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data);
static GVariant* dbus_service_id_bus_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data);
static gboolean dbus_service_id_bus_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data);
static void _dbus_dbus_service_id_bus_name_acquired (GObject* _sender, const gchar* name, gpointer* _data);
static void _dbus_dbus_service_id_bus_name_lost (GObject* _sender, const gchar* name, gpointer* _data);
static void _dbus_dbus_service_id_bus_name_owner_changed (GObject* _sender, const gchar* name, const gchar* oldowner, const gchar* newowner, gpointer* _data);
static void _dbus_service_id_bus_unregister_object (gpointer user_data);
GType dbus_service_id_bus_sync_proxy_get_type (void) G_GNUC_CONST;
guint dbus_service_id_bus_sync_register_object (void* object, GDBusConnection* connection, const gchar* path, GError** error);
GType dbus_service_id_bus_sync_get_type (void) G_GNUC_CONST;
void dbus_service_id_bus_sync_AddMatch (DBusServiceIDBusSync* self, const gchar* match, GError** error);
guint8* dbus_service_id_bus_sync_GetAdtAuditSessionData (DBusServiceIDBusSync* self, const gchar* type, int* result_length1, GError** error);
guint8* dbus_service_id_bus_sync_GetConnectionSELinuxSecurityContext (DBusServiceIDBusSync* self, const gchar* type, int* result_length1, GError** error);
guint32 dbus_service_id_bus_sync_GetConnectionUnixProcessID (DBusServiceIDBusSync* self, const gchar* conn, GError** error);
guint32 dbus_service_id_bus_sync_GetConnectionUnixUser (DBusServiceIDBusSync* self, const gchar* conn, GError** error);
gchar* dbus_service_id_bus_sync_GetId (DBusServiceIDBusSync* self, GError** error);
gchar* dbus_service_id_bus_sync_GetNameOwner (DBusServiceIDBusSync* self, const gchar* name, GError** error);
gchar* dbus_service_id_bus_sync_Hello (DBusServiceIDBusSync* self, GError** error);
gchar** dbus_service_id_bus_sync_ListActivatableNames (DBusServiceIDBusSync* self, int* result_length1, GError** error);
gchar** dbus_service_id_bus_sync_ListNames (DBusServiceIDBusSync* self, int* result_length1, GError** error);
gchar** dbus_service_id_bus_sync_ListQueuedOwners (DBusServiceIDBusSync* self, const gchar* None, int* result_length1, GError** error);
gboolean dbus_service_id_bus_sync_NameHasOwner (DBusServiceIDBusSync* self, const gchar* name, GError** error);
guint32 dbus_service_id_bus_sync_ReleaseName (DBusServiceIDBusSync* self, const gchar* name, GError** error);
void dbus_service_id_bus_sync_ReloadConfig (DBusServiceIDBusSync* self, GError** error);
void dbus_service_id_bus_sync_RemoveMatch (DBusServiceIDBusSync* self, const gchar* match, GError** error);
guint32 dbus_service_id_bus_sync_RequestName (DBusServiceIDBusSync* self, const gchar* name, guint32 flags, GError** error);
guint32 dbus_service_id_bus_sync_StartServiceByName (DBusServiceIDBusSync* self, const gchar* name, guint32 flags, GError** error);
void dbus_service_id_bus_sync_UpdateActivationEnvironment (DBusServiceIDBusSync* self, GHashTable* environment, GError** error);
static void dbus_service_id_bus_sync_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters);
static void _dbus_handle_dbus_service_id_bus_sync_name_acquired (DBusServiceIDBusSync* self, GVariant* parameters);
static void _dbus_handle_dbus_service_id_bus_sync_name_lost (DBusServiceIDBusSync* self, GVariant* parameters);
static void _dbus_handle_dbus_service_id_bus_sync_name_owner_changed (DBusServiceIDBusSync* self, GVariant* parameters);
static void dbus_service_id_bus_sync_proxy_AddMatch (DBusServiceIDBusSync* self, const gchar* match, GError** error);
static guint8* dbus_service_id_bus_sync_proxy_GetAdtAuditSessionData (DBusServiceIDBusSync* self, const gchar* type, int* result_length1, GError** error);
static guint8* dbus_service_id_bus_sync_proxy_GetConnectionSELinuxSecurityContext (DBusServiceIDBusSync* self, const gchar* type, int* result_length1, GError** error);
static guint32 dbus_service_id_bus_sync_proxy_GetConnectionUnixProcessID (DBusServiceIDBusSync* self, const gchar* conn, GError** error);
static guint32 dbus_service_id_bus_sync_proxy_GetConnectionUnixUser (DBusServiceIDBusSync* self, const gchar* conn, GError** error);
static gchar* dbus_service_id_bus_sync_proxy_GetId (DBusServiceIDBusSync* self, GError** error);
static gchar* dbus_service_id_bus_sync_proxy_GetNameOwner (DBusServiceIDBusSync* self, const gchar* name, GError** error);
static gchar* dbus_service_id_bus_sync_proxy_Hello (DBusServiceIDBusSync* self, GError** error);
static gchar** dbus_service_id_bus_sync_proxy_ListActivatableNames (DBusServiceIDBusSync* self, int* result_length1, GError** error);
static gchar** dbus_service_id_bus_sync_proxy_ListNames (DBusServiceIDBusSync* self, int* result_length1, GError** error);
static gchar** dbus_service_id_bus_sync_proxy_ListQueuedOwners (DBusServiceIDBusSync* self, const gchar* None, int* result_length1, GError** error);
static gboolean dbus_service_id_bus_sync_proxy_NameHasOwner (DBusServiceIDBusSync* self, const gchar* name, GError** error);
static guint32 dbus_service_id_bus_sync_proxy_ReleaseName (DBusServiceIDBusSync* self, const gchar* name, GError** error);
static void dbus_service_id_bus_sync_proxy_ReloadConfig (DBusServiceIDBusSync* self, GError** error);
static void dbus_service_id_bus_sync_proxy_RemoveMatch (DBusServiceIDBusSync* self, const gchar* match, GError** error);
static guint32 dbus_service_id_bus_sync_proxy_RequestName (DBusServiceIDBusSync* self, const gchar* name, guint32 flags, GError** error);
static guint32 dbus_service_id_bus_sync_proxy_StartServiceByName (DBusServiceIDBusSync* self, const gchar* name, guint32 flags, GError** error);
static void dbus_service_id_bus_sync_proxy_UpdateActivationEnvironment (DBusServiceIDBusSync* self, GHashTable* environment, GError** error);
static void dbus_service_id_bus_sync_proxy_dbus_service_id_bus_sync_interface_init (DBusServiceIDBusSyncIface* iface);
static void _dbus_dbus_service_id_bus_sync_AddMatch (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_GetAdtAuditSessionData (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_GetConnectionSELinuxSecurityContext (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_GetConnectionUnixProcessID (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_GetConnectionUnixUser (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_GetId (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_GetNameOwner (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_Hello (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_ListActivatableNames (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_ListNames (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_ListQueuedOwners (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_NameHasOwner (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_ReleaseName (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_ReloadConfig (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_RemoveMatch (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_RequestName (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_StartServiceByName (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void _dbus_dbus_service_id_bus_sync_UpdateActivationEnvironment (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation);
static void dbus_service_id_bus_sync_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data);
static GVariant* dbus_service_id_bus_sync_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data);
static gboolean dbus_service_id_bus_sync_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data);
static void _dbus_dbus_service_id_bus_sync_name_acquired (GObject* _sender, const gchar* name, gpointer* _data);
static void _dbus_dbus_service_id_bus_sync_name_lost (GObject* _sender, const gchar* name, gpointer* _data);
static void _dbus_dbus_service_id_bus_sync_name_owner_changed (GObject* _sender, const gchar* name, const gchar* oldowner, const gchar* newowner, gpointer* _data);
static void _dbus_service_id_bus_sync_unregister_object (gpointer user_data);
gboolean fso_framework_isValidDBusName (const gchar* busname);
void dbus_func_delegate_holder_free (DBusFuncDelegateHolder* self);
static void dbus_func_delegate_holder_instance_init (DBusFuncDelegateHolder * self);
DBusFuncDelegateHolder* dbus_func_delegate_holder_new (FsoFrameworkDBusServiceEventFunc func, void* func_target);
DBusFuncDelegateHolder* dbus_func_delegate_holder_new (FsoFrameworkDBusServiceEventFunc func, void* func_target);
gpointer fso_framework_dbus_service_notifier_delegate_ref (gpointer instance);
void fso_framework_dbus_service_notifier_delegate_unref (gpointer instance);
GParamSpec* fso_framework_param_spec_dbus_service_notifier_delegate (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags);
void fso_framework_value_set_dbus_service_notifier_delegate (GValue* value, gpointer v_object);
void fso_framework_value_take_dbus_service_notifier_delegate (GValue* value, gpointer v_object);
gpointer fso_framework_value_get_dbus_service_notifier_delegate (const GValue* value);
GType fso_framework_dbus_service_notifier_delegate_get_type (void) G_GNUC_CONST;
#define FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_DELEGATE_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE, FsoFrameworkDBusServiceNotifierDelegatePrivate))
enum  {
	FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_DELEGATE_DUMMY_PROPERTY
};
FsoFrameworkDBusServiceNotifierDelegate* fso_framework_dbus_service_notifier_delegate_new (GType t_type, GBoxedCopyFunc t_dup_func, GDestroyNotify t_destroy_func, gpointer t);
FsoFrameworkDBusServiceNotifierDelegate* fso_framework_dbus_service_notifier_delegate_construct (GType object_type, GType t_type, GBoxedCopyFunc t_dup_func, GDestroyNotify t_destroy_func, gpointer t);
static void fso_framework_dbus_service_notifier_delegate_finalize (FsoFrameworkDBusServiceNotifierDelegate* obj);
GType fso_framework_dbus_service_notifier_get_type (void) G_GNUC_CONST;
#define FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER, FsoFrameworkDBusServiceNotifierPrivate))
enum  {
	FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_DUMMY_PROPERTY
};
FsoFrameworkDBusServiceNotifier* fso_framework_dbus_service_notifier_new (void);
FsoFrameworkDBusServiceNotifier* fso_framework_dbus_service_notifier_construct (GType object_type);
static void _g_free0_ (gpointer var);
static void _dbus_func_delegate_holder_free0_ (gpointer var);
static void _g_list_free__dbus_func_delegate_holder_free0_ (GList* self);
static void __g_list_free__dbus_func_delegate_holder_free0_0_ (gpointer var);
static void fso_framework_dbus_service_notifier_onNameOwnerChanged (FsoFrameworkDBusServiceNotifier* self, GObject* obj, const gchar* name, const gchar* oldowner, const gchar* newowner);
static void _fso_framework_dbus_service_notifier_onNameOwnerChanged_dbus_service_id_bus_name_owner_changed (DBusServiceIDBus* _sender, const gchar* name, const gchar* oldowner, const gchar* newowner, gpointer self);
static gchar* fso_framework_dbus_service_notifier_real_repr (FsoFrameworkAbstractObject* base);
void fso_framework_dbus_service_notifier_notifyAppearing (FsoFrameworkDBusServiceNotifier* self, const gchar* busname, FsoFrameworkDBusServiceEventFunc callback, void* callback_target);
void fso_framework_dbus_service_notifier_notifyDisappearing (FsoFrameworkDBusServiceNotifier* self, const gchar* busname, FsoFrameworkDBusServiceEventFunc callback, void* callback_target);
static void fso_framework_dbus_service_notifier_finalize (GObject* obj);
static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func);
static gint _vala_array_length (gpointer array);

static const GDBusArgInfo _dbus_service_iintrospectable_dbus_arg_info_Introspect_result = {-1, "result", "s"};
static const GDBusArgInfo * const _dbus_service_iintrospectable_dbus_arg_info_Introspect_in[] = {NULL};
static const GDBusArgInfo * const _dbus_service_iintrospectable_dbus_arg_info_Introspect_out[] = {&_dbus_service_iintrospectable_dbus_arg_info_Introspect_result, NULL};
static const GDBusMethodInfo _dbus_service_iintrospectable_dbus_method_info_Introspect = {-1, "Introspect", (GDBusArgInfo **) (&_dbus_service_iintrospectable_dbus_arg_info_Introspect_in), (GDBusArgInfo **) (&_dbus_service_iintrospectable_dbus_arg_info_Introspect_out)};
static const GDBusMethodInfo * const _dbus_service_iintrospectable_dbus_method_info[] = {&_dbus_service_iintrospectable_dbus_method_info_Introspect, NULL};
static const GDBusSignalInfo * const _dbus_service_iintrospectable_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo * const _dbus_service_iintrospectable_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _dbus_service_iintrospectable_dbus_interface_info = {-1, "org.freedesktop.DBus.Introspectable", (GDBusMethodInfo **) (&_dbus_service_iintrospectable_dbus_method_info), (GDBusSignalInfo **) (&_dbus_service_iintrospectable_dbus_signal_info), (GDBusPropertyInfo **) (&_dbus_service_iintrospectable_dbus_property_info)};
static const GDBusInterfaceVTable _dbus_service_iintrospectable_dbus_interface_vtable = {dbus_service_iintrospectable_dbus_interface_method_call, dbus_service_iintrospectable_dbus_interface_get_property, dbus_service_iintrospectable_dbus_interface_set_property};
static const GDBusArgInfo _dbus_service_iproperties_dbus_arg_info_Get_iface = {-1, "iface", "s"};
static const GDBusArgInfo _dbus_service_iproperties_dbus_arg_info_Get_prop = {-1, "prop", "s"};
static const GDBusArgInfo _dbus_service_iproperties_dbus_arg_info_Get_result = {-1, "result", "v"};
static const GDBusArgInfo * const _dbus_service_iproperties_dbus_arg_info_Get_in[] = {&_dbus_service_iproperties_dbus_arg_info_Get_iface, &_dbus_service_iproperties_dbus_arg_info_Get_prop, NULL};
static const GDBusArgInfo * const _dbus_service_iproperties_dbus_arg_info_Get_out[] = {&_dbus_service_iproperties_dbus_arg_info_Get_result, NULL};
static const GDBusMethodInfo _dbus_service_iproperties_dbus_method_info_Get = {-1, "Get", (GDBusArgInfo **) (&_dbus_service_iproperties_dbus_arg_info_Get_in), (GDBusArgInfo **) (&_dbus_service_iproperties_dbus_arg_info_Get_out)};
static const GDBusArgInfo _dbus_service_iproperties_dbus_arg_info_Set_iface = {-1, "iface", "s"};
static const GDBusArgInfo _dbus_service_iproperties_dbus_arg_info_Set_prop = {-1, "prop", "s"};
static const GDBusArgInfo _dbus_service_iproperties_dbus_arg_info_Set_val = {-1, "val", "v"};
static const GDBusArgInfo * const _dbus_service_iproperties_dbus_arg_info_Set_in[] = {&_dbus_service_iproperties_dbus_arg_info_Set_iface, &_dbus_service_iproperties_dbus_arg_info_Set_prop, &_dbus_service_iproperties_dbus_arg_info_Set_val, NULL};
static const GDBusArgInfo * const _dbus_service_iproperties_dbus_arg_info_Set_out[] = {NULL};
static const GDBusMethodInfo _dbus_service_iproperties_dbus_method_info_Set = {-1, "Set", (GDBusArgInfo **) (&_dbus_service_iproperties_dbus_arg_info_Set_in), (GDBusArgInfo **) (&_dbus_service_iproperties_dbus_arg_info_Set_out)};
static const GDBusArgInfo _dbus_service_iproperties_dbus_arg_info_GetAll_iface = {-1, "iface", "s"};
static const GDBusArgInfo _dbus_service_iproperties_dbus_arg_info_GetAll_result = {-1, "result", "a{sv}"};
static const GDBusArgInfo * const _dbus_service_iproperties_dbus_arg_info_GetAll_in[] = {&_dbus_service_iproperties_dbus_arg_info_GetAll_iface, NULL};
static const GDBusArgInfo * const _dbus_service_iproperties_dbus_arg_info_GetAll_out[] = {&_dbus_service_iproperties_dbus_arg_info_GetAll_result, NULL};
static const GDBusMethodInfo _dbus_service_iproperties_dbus_method_info_GetAll = {-1, "GetAll", (GDBusArgInfo **) (&_dbus_service_iproperties_dbus_arg_info_GetAll_in), (GDBusArgInfo **) (&_dbus_service_iproperties_dbus_arg_info_GetAll_out)};
static const GDBusMethodInfo * const _dbus_service_iproperties_dbus_method_info[] = {&_dbus_service_iproperties_dbus_method_info_Get, &_dbus_service_iproperties_dbus_method_info_Set, &_dbus_service_iproperties_dbus_method_info_GetAll, NULL};
static const GDBusSignalInfo * const _dbus_service_iproperties_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo * const _dbus_service_iproperties_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _dbus_service_iproperties_dbus_interface_info = {-1, "org.freedesktop.DBus.Properties", (GDBusMethodInfo **) (&_dbus_service_iproperties_dbus_method_info), (GDBusSignalInfo **) (&_dbus_service_iproperties_dbus_signal_info), (GDBusPropertyInfo **) (&_dbus_service_iproperties_dbus_property_info)};
static const GDBusInterfaceVTable _dbus_service_iproperties_dbus_interface_vtable = {dbus_service_iproperties_dbus_interface_method_call, dbus_service_iproperties_dbus_interface_get_property, dbus_service_iproperties_dbus_interface_set_property};
static const GDBusArgInfo * const _dbus_service_ipeer_dbus_arg_info_Ping_in[] = {NULL};
static const GDBusArgInfo * const _dbus_service_ipeer_dbus_arg_info_Ping_out[] = {NULL};
static const GDBusMethodInfo _dbus_service_ipeer_dbus_method_info_Ping = {-1, "Ping", (GDBusArgInfo **) (&_dbus_service_ipeer_dbus_arg_info_Ping_in), (GDBusArgInfo **) (&_dbus_service_ipeer_dbus_arg_info_Ping_out)};
static const GDBusMethodInfo * const _dbus_service_ipeer_dbus_method_info[] = {&_dbus_service_ipeer_dbus_method_info_Ping, NULL};
static const GDBusSignalInfo * const _dbus_service_ipeer_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo * const _dbus_service_ipeer_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _dbus_service_ipeer_dbus_interface_info = {-1, "org.freedesktop.DBus.Peer", (GDBusMethodInfo **) (&_dbus_service_ipeer_dbus_method_info), (GDBusSignalInfo **) (&_dbus_service_ipeer_dbus_signal_info), (GDBusPropertyInfo **) (&_dbus_service_ipeer_dbus_property_info)};
static const GDBusInterfaceVTable _dbus_service_ipeer_dbus_interface_vtable = {dbus_service_ipeer_dbus_interface_method_call, dbus_service_ipeer_dbus_interface_get_property, dbus_service_ipeer_dbus_interface_set_property};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_AddMatch_match = {-1, "match", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_AddMatch_in[] = {&_dbus_service_id_bus_dbus_arg_info_AddMatch_match, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_AddMatch_out[] = {NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_AddMatch = {-1, "AddMatch", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_AddMatch_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_AddMatch_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_GetAdtAuditSessionData_type = {-1, "type", "s"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_GetAdtAuditSessionData_result = {-1, "result", "ay"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_GetAdtAuditSessionData_in[] = {&_dbus_service_id_bus_dbus_arg_info_GetAdtAuditSessionData_type, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_GetAdtAuditSessionData_out[] = {&_dbus_service_id_bus_dbus_arg_info_GetAdtAuditSessionData_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_GetAdtAuditSessionData = {-1, "GetAdtAuditSessionData", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_GetAdtAuditSessionData_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_GetAdtAuditSessionData_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_GetConnectionSELinuxSecurityContext_type = {-1, "type", "s"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_GetConnectionSELinuxSecurityContext_result = {-1, "result", "ay"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_GetConnectionSELinuxSecurityContext_in[] = {&_dbus_service_id_bus_dbus_arg_info_GetConnectionSELinuxSecurityContext_type, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_GetConnectionSELinuxSecurityContext_out[] = {&_dbus_service_id_bus_dbus_arg_info_GetConnectionSELinuxSecurityContext_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_GetConnectionSELinuxSecurityContext = {-1, "GetConnectionSELinuxSecurityContext", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_GetConnectionSELinuxSecurityContext_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_GetConnectionSELinuxSecurityContext_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_GetConnectionUnixProcessID_conn = {-1, "conn", "s"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_GetConnectionUnixProcessID_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_GetConnectionUnixProcessID_in[] = {&_dbus_service_id_bus_dbus_arg_info_GetConnectionUnixProcessID_conn, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_GetConnectionUnixProcessID_out[] = {&_dbus_service_id_bus_dbus_arg_info_GetConnectionUnixProcessID_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_GetConnectionUnixProcessID = {-1, "GetConnectionUnixProcessID", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_GetConnectionUnixProcessID_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_GetConnectionUnixProcessID_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_GetConnectionUnixUser_conn = {-1, "conn", "s"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_GetConnectionUnixUser_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_GetConnectionUnixUser_in[] = {&_dbus_service_id_bus_dbus_arg_info_GetConnectionUnixUser_conn, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_GetConnectionUnixUser_out[] = {&_dbus_service_id_bus_dbus_arg_info_GetConnectionUnixUser_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_GetConnectionUnixUser = {-1, "GetConnectionUnixUser", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_GetConnectionUnixUser_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_GetConnectionUnixUser_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_GetId_result = {-1, "result", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_GetId_in[] = {NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_GetId_out[] = {&_dbus_service_id_bus_dbus_arg_info_GetId_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_GetId = {-1, "GetId", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_GetId_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_GetId_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_GetNameOwner_name = {-1, "name", "s"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_GetNameOwner_result = {-1, "result", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_GetNameOwner_in[] = {&_dbus_service_id_bus_dbus_arg_info_GetNameOwner_name, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_GetNameOwner_out[] = {&_dbus_service_id_bus_dbus_arg_info_GetNameOwner_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_GetNameOwner = {-1, "GetNameOwner", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_GetNameOwner_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_GetNameOwner_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_Hello_result = {-1, "result", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_Hello_in[] = {NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_Hello_out[] = {&_dbus_service_id_bus_dbus_arg_info_Hello_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_Hello = {-1, "Hello", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_Hello_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_Hello_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_ListActivatableNames_result = {-1, "result", "as"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_ListActivatableNames_in[] = {NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_ListActivatableNames_out[] = {&_dbus_service_id_bus_dbus_arg_info_ListActivatableNames_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_ListActivatableNames = {-1, "ListActivatableNames", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_ListActivatableNames_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_ListActivatableNames_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_ListNames_result = {-1, "result", "as"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_ListNames_in[] = {NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_ListNames_out[] = {&_dbus_service_id_bus_dbus_arg_info_ListNames_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_ListNames = {-1, "ListNames", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_ListNames_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_ListNames_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_ListQueuedOwners_None = {-1, "None", "s"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_ListQueuedOwners_result = {-1, "result", "as"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_ListQueuedOwners_in[] = {&_dbus_service_id_bus_dbus_arg_info_ListQueuedOwners_None, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_ListQueuedOwners_out[] = {&_dbus_service_id_bus_dbus_arg_info_ListQueuedOwners_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_ListQueuedOwners = {-1, "ListQueuedOwners", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_ListQueuedOwners_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_ListQueuedOwners_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_NameHasOwner_name = {-1, "name", "s"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_NameHasOwner_result = {-1, "result", "b"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_NameHasOwner_in[] = {&_dbus_service_id_bus_dbus_arg_info_NameHasOwner_name, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_NameHasOwner_out[] = {&_dbus_service_id_bus_dbus_arg_info_NameHasOwner_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_NameHasOwner = {-1, "NameHasOwner", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_NameHasOwner_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_NameHasOwner_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_ReleaseName_name = {-1, "name", "s"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_ReleaseName_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_ReleaseName_in[] = {&_dbus_service_id_bus_dbus_arg_info_ReleaseName_name, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_ReleaseName_out[] = {&_dbus_service_id_bus_dbus_arg_info_ReleaseName_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_ReleaseName = {-1, "ReleaseName", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_ReleaseName_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_ReleaseName_out)};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_ReloadConfig_in[] = {NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_ReloadConfig_out[] = {NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_ReloadConfig = {-1, "ReloadConfig", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_ReloadConfig_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_ReloadConfig_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_RemoveMatch_match = {-1, "match", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_RemoveMatch_in[] = {&_dbus_service_id_bus_dbus_arg_info_RemoveMatch_match, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_RemoveMatch_out[] = {NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_RemoveMatch = {-1, "RemoveMatch", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_RemoveMatch_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_RemoveMatch_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_RequestName_name = {-1, "name", "s"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_RequestName_flags = {-1, "flags", "u"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_RequestName_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_RequestName_in[] = {&_dbus_service_id_bus_dbus_arg_info_RequestName_name, &_dbus_service_id_bus_dbus_arg_info_RequestName_flags, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_RequestName_out[] = {&_dbus_service_id_bus_dbus_arg_info_RequestName_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_RequestName = {-1, "RequestName", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_RequestName_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_RequestName_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_StartServiceByName_name = {-1, "name", "s"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_StartServiceByName_flags = {-1, "flags", "u"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_StartServiceByName_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_StartServiceByName_in[] = {&_dbus_service_id_bus_dbus_arg_info_StartServiceByName_name, &_dbus_service_id_bus_dbus_arg_info_StartServiceByName_flags, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_StartServiceByName_out[] = {&_dbus_service_id_bus_dbus_arg_info_StartServiceByName_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_StartServiceByName = {-1, "StartServiceByName", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_StartServiceByName_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_StartServiceByName_out)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_UpdateActivationEnvironment_environment = {-1, "environment", "a{ss}"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_UpdateActivationEnvironment_in[] = {&_dbus_service_id_bus_dbus_arg_info_UpdateActivationEnvironment_environment, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_UpdateActivationEnvironment_out[] = {NULL};
static const GDBusMethodInfo _dbus_service_id_bus_dbus_method_info_UpdateActivationEnvironment = {-1, "UpdateActivationEnvironment", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_UpdateActivationEnvironment_in), (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_UpdateActivationEnvironment_out)};
static const GDBusMethodInfo * const _dbus_service_id_bus_dbus_method_info[] = {&_dbus_service_id_bus_dbus_method_info_AddMatch, &_dbus_service_id_bus_dbus_method_info_GetAdtAuditSessionData, &_dbus_service_id_bus_dbus_method_info_GetConnectionSELinuxSecurityContext, &_dbus_service_id_bus_dbus_method_info_GetConnectionUnixProcessID, &_dbus_service_id_bus_dbus_method_info_GetConnectionUnixUser, &_dbus_service_id_bus_dbus_method_info_GetId, &_dbus_service_id_bus_dbus_method_info_GetNameOwner, &_dbus_service_id_bus_dbus_method_info_Hello, &_dbus_service_id_bus_dbus_method_info_ListActivatableNames, &_dbus_service_id_bus_dbus_method_info_ListNames, &_dbus_service_id_bus_dbus_method_info_ListQueuedOwners, &_dbus_service_id_bus_dbus_method_info_NameHasOwner, &_dbus_service_id_bus_dbus_method_info_ReleaseName, &_dbus_service_id_bus_dbus_method_info_ReloadConfig, &_dbus_service_id_bus_dbus_method_info_RemoveMatch, &_dbus_service_id_bus_dbus_method_info_RequestName, &_dbus_service_id_bus_dbus_method_info_StartServiceByName, &_dbus_service_id_bus_dbus_method_info_UpdateActivationEnvironment, NULL};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_name_acquired_name = {-1, "name", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_name_acquired[] = {&_dbus_service_id_bus_dbus_arg_info_name_acquired_name, NULL};
static const GDBusSignalInfo _dbus_service_id_bus_dbus_signal_info_name_acquired = {-1, "NameAcquired", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_name_acquired)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_name_lost_name = {-1, "name", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_name_lost[] = {&_dbus_service_id_bus_dbus_arg_info_name_lost_name, NULL};
static const GDBusSignalInfo _dbus_service_id_bus_dbus_signal_info_name_lost = {-1, "NameLost", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_name_lost)};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_name_owner_changed_name = {-1, "name", "s"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_name_owner_changed_oldowner = {-1, "oldowner", "s"};
static const GDBusArgInfo _dbus_service_id_bus_dbus_arg_info_name_owner_changed_newowner = {-1, "newowner", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_dbus_arg_info_name_owner_changed[] = {&_dbus_service_id_bus_dbus_arg_info_name_owner_changed_name, &_dbus_service_id_bus_dbus_arg_info_name_owner_changed_oldowner, &_dbus_service_id_bus_dbus_arg_info_name_owner_changed_newowner, NULL};
static const GDBusSignalInfo _dbus_service_id_bus_dbus_signal_info_name_owner_changed = {-1, "NameOwnerChanged", (GDBusArgInfo **) (&_dbus_service_id_bus_dbus_arg_info_name_owner_changed)};
static const GDBusSignalInfo * const _dbus_service_id_bus_dbus_signal_info[] = {&_dbus_service_id_bus_dbus_signal_info_name_acquired, &_dbus_service_id_bus_dbus_signal_info_name_lost, &_dbus_service_id_bus_dbus_signal_info_name_owner_changed, NULL};
static const GDBusPropertyInfo * const _dbus_service_id_bus_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _dbus_service_id_bus_dbus_interface_info = {-1, "org.freedesktop.DBus", (GDBusMethodInfo **) (&_dbus_service_id_bus_dbus_method_info), (GDBusSignalInfo **) (&_dbus_service_id_bus_dbus_signal_info), (GDBusPropertyInfo **) (&_dbus_service_id_bus_dbus_property_info)};
static const GDBusInterfaceVTable _dbus_service_id_bus_dbus_interface_vtable = {dbus_service_id_bus_dbus_interface_method_call, dbus_service_id_bus_dbus_interface_get_property, dbus_service_id_bus_dbus_interface_set_property};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_AddMatch_match = {-1, "match", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_AddMatch_in[] = {&_dbus_service_id_bus_sync_dbus_arg_info_AddMatch_match, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_AddMatch_out[] = {NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_AddMatch = {-1, "AddMatch", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_AddMatch_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_AddMatch_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_GetAdtAuditSessionData_type = {-1, "type", "s"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_GetAdtAuditSessionData_result = {-1, "result", "ay"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_GetAdtAuditSessionData_in[] = {&_dbus_service_id_bus_sync_dbus_arg_info_GetAdtAuditSessionData_type, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_GetAdtAuditSessionData_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_GetAdtAuditSessionData_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_GetAdtAuditSessionData = {-1, "GetAdtAuditSessionData", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_GetAdtAuditSessionData_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_GetAdtAuditSessionData_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_GetConnectionSELinuxSecurityContext_type = {-1, "type", "s"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_GetConnectionSELinuxSecurityContext_result = {-1, "result", "ay"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_GetConnectionSELinuxSecurityContext_in[] = {&_dbus_service_id_bus_sync_dbus_arg_info_GetConnectionSELinuxSecurityContext_type, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_GetConnectionSELinuxSecurityContext_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_GetConnectionSELinuxSecurityContext_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_GetConnectionSELinuxSecurityContext = {-1, "GetConnectionSELinuxSecurityContext", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_GetConnectionSELinuxSecurityContext_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_GetConnectionSELinuxSecurityContext_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixProcessID_conn = {-1, "conn", "s"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixProcessID_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixProcessID_in[] = {&_dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixProcessID_conn, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixProcessID_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixProcessID_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_GetConnectionUnixProcessID = {-1, "GetConnectionUnixProcessID", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixProcessID_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixProcessID_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixUser_conn = {-1, "conn", "s"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixUser_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixUser_in[] = {&_dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixUser_conn, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixUser_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixUser_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_GetConnectionUnixUser = {-1, "GetConnectionUnixUser", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixUser_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_GetConnectionUnixUser_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_GetId_result = {-1, "result", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_GetId_in[] = {NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_GetId_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_GetId_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_GetId = {-1, "GetId", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_GetId_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_GetId_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_GetNameOwner_name = {-1, "name", "s"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_GetNameOwner_result = {-1, "result", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_GetNameOwner_in[] = {&_dbus_service_id_bus_sync_dbus_arg_info_GetNameOwner_name, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_GetNameOwner_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_GetNameOwner_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_GetNameOwner = {-1, "GetNameOwner", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_GetNameOwner_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_GetNameOwner_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_Hello_result = {-1, "result", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_Hello_in[] = {NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_Hello_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_Hello_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_Hello = {-1, "Hello", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_Hello_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_Hello_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_ListActivatableNames_result = {-1, "result", "as"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_ListActivatableNames_in[] = {NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_ListActivatableNames_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_ListActivatableNames_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_ListActivatableNames = {-1, "ListActivatableNames", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_ListActivatableNames_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_ListActivatableNames_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_ListNames_result = {-1, "result", "as"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_ListNames_in[] = {NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_ListNames_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_ListNames_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_ListNames = {-1, "ListNames", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_ListNames_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_ListNames_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_ListQueuedOwners_None = {-1, "None", "s"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_ListQueuedOwners_result = {-1, "result", "as"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_ListQueuedOwners_in[] = {&_dbus_service_id_bus_sync_dbus_arg_info_ListQueuedOwners_None, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_ListQueuedOwners_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_ListQueuedOwners_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_ListQueuedOwners = {-1, "ListQueuedOwners", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_ListQueuedOwners_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_ListQueuedOwners_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_NameHasOwner_name = {-1, "name", "s"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_NameHasOwner_result = {-1, "result", "b"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_NameHasOwner_in[] = {&_dbus_service_id_bus_sync_dbus_arg_info_NameHasOwner_name, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_NameHasOwner_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_NameHasOwner_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_NameHasOwner = {-1, "NameHasOwner", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_NameHasOwner_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_NameHasOwner_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_ReleaseName_name = {-1, "name", "s"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_ReleaseName_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_ReleaseName_in[] = {&_dbus_service_id_bus_sync_dbus_arg_info_ReleaseName_name, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_ReleaseName_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_ReleaseName_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_ReleaseName = {-1, "ReleaseName", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_ReleaseName_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_ReleaseName_out)};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_ReloadConfig_in[] = {NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_ReloadConfig_out[] = {NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_ReloadConfig = {-1, "ReloadConfig", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_ReloadConfig_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_ReloadConfig_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_RemoveMatch_match = {-1, "match", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_RemoveMatch_in[] = {&_dbus_service_id_bus_sync_dbus_arg_info_RemoveMatch_match, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_RemoveMatch_out[] = {NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_RemoveMatch = {-1, "RemoveMatch", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_RemoveMatch_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_RemoveMatch_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_RequestName_name = {-1, "name", "s"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_RequestName_flags = {-1, "flags", "u"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_RequestName_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_RequestName_in[] = {&_dbus_service_id_bus_sync_dbus_arg_info_RequestName_name, &_dbus_service_id_bus_sync_dbus_arg_info_RequestName_flags, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_RequestName_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_RequestName_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_RequestName = {-1, "RequestName", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_RequestName_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_RequestName_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_StartServiceByName_name = {-1, "name", "s"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_StartServiceByName_flags = {-1, "flags", "u"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_StartServiceByName_result = {-1, "result", "u"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_StartServiceByName_in[] = {&_dbus_service_id_bus_sync_dbus_arg_info_StartServiceByName_name, &_dbus_service_id_bus_sync_dbus_arg_info_StartServiceByName_flags, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_StartServiceByName_out[] = {&_dbus_service_id_bus_sync_dbus_arg_info_StartServiceByName_result, NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_StartServiceByName = {-1, "StartServiceByName", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_StartServiceByName_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_StartServiceByName_out)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_UpdateActivationEnvironment_environment = {-1, "environment", "a{ss}"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_UpdateActivationEnvironment_in[] = {&_dbus_service_id_bus_sync_dbus_arg_info_UpdateActivationEnvironment_environment, NULL};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_UpdateActivationEnvironment_out[] = {NULL};
static const GDBusMethodInfo _dbus_service_id_bus_sync_dbus_method_info_UpdateActivationEnvironment = {-1, "UpdateActivationEnvironment", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_UpdateActivationEnvironment_in), (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_UpdateActivationEnvironment_out)};
static const GDBusMethodInfo * const _dbus_service_id_bus_sync_dbus_method_info[] = {&_dbus_service_id_bus_sync_dbus_method_info_AddMatch, &_dbus_service_id_bus_sync_dbus_method_info_GetAdtAuditSessionData, &_dbus_service_id_bus_sync_dbus_method_info_GetConnectionSELinuxSecurityContext, &_dbus_service_id_bus_sync_dbus_method_info_GetConnectionUnixProcessID, &_dbus_service_id_bus_sync_dbus_method_info_GetConnectionUnixUser, &_dbus_service_id_bus_sync_dbus_method_info_GetId, &_dbus_service_id_bus_sync_dbus_method_info_GetNameOwner, &_dbus_service_id_bus_sync_dbus_method_info_Hello, &_dbus_service_id_bus_sync_dbus_method_info_ListActivatableNames, &_dbus_service_id_bus_sync_dbus_method_info_ListNames, &_dbus_service_id_bus_sync_dbus_method_info_ListQueuedOwners, &_dbus_service_id_bus_sync_dbus_method_info_NameHasOwner, &_dbus_service_id_bus_sync_dbus_method_info_ReleaseName, &_dbus_service_id_bus_sync_dbus_method_info_ReloadConfig, &_dbus_service_id_bus_sync_dbus_method_info_RemoveMatch, &_dbus_service_id_bus_sync_dbus_method_info_RequestName, &_dbus_service_id_bus_sync_dbus_method_info_StartServiceByName, &_dbus_service_id_bus_sync_dbus_method_info_UpdateActivationEnvironment, NULL};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_name_acquired_name = {-1, "name", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_name_acquired[] = {&_dbus_service_id_bus_sync_dbus_arg_info_name_acquired_name, NULL};
static const GDBusSignalInfo _dbus_service_id_bus_sync_dbus_signal_info_name_acquired = {-1, "NameAcquired", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_name_acquired)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_name_lost_name = {-1, "name", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_name_lost[] = {&_dbus_service_id_bus_sync_dbus_arg_info_name_lost_name, NULL};
static const GDBusSignalInfo _dbus_service_id_bus_sync_dbus_signal_info_name_lost = {-1, "NameLost", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_name_lost)};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_name_owner_changed_name = {-1, "name", "s"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_name_owner_changed_oldowner = {-1, "oldowner", "s"};
static const GDBusArgInfo _dbus_service_id_bus_sync_dbus_arg_info_name_owner_changed_newowner = {-1, "newowner", "s"};
static const GDBusArgInfo * const _dbus_service_id_bus_sync_dbus_arg_info_name_owner_changed[] = {&_dbus_service_id_bus_sync_dbus_arg_info_name_owner_changed_name, &_dbus_service_id_bus_sync_dbus_arg_info_name_owner_changed_oldowner, &_dbus_service_id_bus_sync_dbus_arg_info_name_owner_changed_newowner, NULL};
static const GDBusSignalInfo _dbus_service_id_bus_sync_dbus_signal_info_name_owner_changed = {-1, "NameOwnerChanged", (GDBusArgInfo **) (&_dbus_service_id_bus_sync_dbus_arg_info_name_owner_changed)};
static const GDBusSignalInfo * const _dbus_service_id_bus_sync_dbus_signal_info[] = {&_dbus_service_id_bus_sync_dbus_signal_info_name_acquired, &_dbus_service_id_bus_sync_dbus_signal_info_name_lost, &_dbus_service_id_bus_sync_dbus_signal_info_name_owner_changed, NULL};
static const GDBusPropertyInfo * const _dbus_service_id_bus_sync_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _dbus_service_id_bus_sync_dbus_interface_info = {-1, "org.freedesktop.DBus", (GDBusMethodInfo **) (&_dbus_service_id_bus_sync_dbus_method_info), (GDBusSignalInfo **) (&_dbus_service_id_bus_sync_dbus_signal_info), (GDBusPropertyInfo **) (&_dbus_service_id_bus_sync_dbus_property_info)};
static const GDBusInterfaceVTable _dbus_service_id_bus_sync_dbus_interface_vtable = {dbus_service_id_bus_sync_dbus_interface_method_call, dbus_service_id_bus_sync_dbus_interface_get_property, dbus_service_id_bus_sync_dbus_interface_set_property};

void dbus_service_iintrospectable_Introspect (DBusServiceIIntrospectable* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_IINTROSPECTABLE_GET_INTERFACE (self)->Introspect (self, _callback_, _user_data_);
}


gchar* dbus_service_iintrospectable_Introspect_finish (DBusServiceIIntrospectable* self, GAsyncResult* _res_, GError** error) {
	return DBUS_SERVICE_IINTROSPECTABLE_GET_INTERFACE (self)->Introspect_finish (self, _res_, error);
}


static void dbus_service_iintrospectable_base_init (DBusServiceIIntrospectableIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
	}
}


GType dbus_service_iintrospectable_get_type (void) {
	static volatile gsize dbus_service_iintrospectable_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_service_iintrospectable_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (DBusServiceIIntrospectableIface), (GBaseInitFunc) dbus_service_iintrospectable_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType dbus_service_iintrospectable_type_id;
		dbus_service_iintrospectable_type_id = g_type_register_static (G_TYPE_INTERFACE, "DBusServiceIIntrospectable", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (dbus_service_iintrospectable_type_id, G_TYPE_OBJECT);
		g_type_set_qdata (dbus_service_iintrospectable_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) dbus_service_iintrospectable_proxy_get_type);
		g_type_set_qdata (dbus_service_iintrospectable_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.freedesktop.DBus.Introspectable");
		g_type_set_qdata (dbus_service_iintrospectable_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) dbus_service_iintrospectable_register_object);
		g_once_init_leave (&dbus_service_iintrospectable_type_id__volatile, dbus_service_iintrospectable_type_id);
	}
	return dbus_service_iintrospectable_type_id__volatile;
}


G_DEFINE_TYPE_EXTENDED (DBusServiceIIntrospectableProxy, dbus_service_iintrospectable_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (DBUS_SERVICE_TYPE_IINTROSPECTABLE, dbus_service_iintrospectable_proxy_dbus_service_iintrospectable_interface_init) )
static void dbus_service_iintrospectable_proxy_class_init (DBusServiceIIntrospectableProxyClass* klass) {
	G_DBUS_PROXY_CLASS (klass)->g_signal = dbus_service_iintrospectable_proxy_g_signal;
}


static void dbus_service_iintrospectable_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters) {
}


static void dbus_service_iintrospectable_proxy_init (DBusServiceIIntrospectableProxy* self) {
}


static void _vala_g_async_ready_callback (GObject *source_object, GAsyncResult *res, void *user_data) {
	g_simple_async_result_set_op_res_gpointer (user_data, g_object_ref (res), g_object_unref);
	g_simple_async_result_complete (user_data);
	g_object_unref (user_data);
}


static void dbus_service_iintrospectable_proxy_Introspect_async (DBusServiceIIntrospectable* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus.Introspectable", "Introspect");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static gchar* dbus_service_iintrospectable_proxy_Introspect_finish (DBusServiceIIntrospectable* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar* _result;
	GVariant* _tmp0_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp0_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_dup_string (_tmp0_, NULL);
	g_variant_unref (_tmp0_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_iintrospectable_proxy_dbus_service_iintrospectable_interface_init (DBusServiceIIntrospectableIface* iface) {
	iface->Introspect = dbus_service_iintrospectable_proxy_Introspect_async;
	iface->Introspect_finish = dbus_service_iintrospectable_proxy_Introspect_finish;
}


static void _dbus_dbus_service_iintrospectable_Introspect (DBusServiceIIntrospectable* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	g_variant_iter_init (&_arguments_iter, parameters);
	dbus_service_iintrospectable_Introspect (self, (GAsyncReadyCallback) _dbus_dbus_service_iintrospectable_Introspect_ready, invocation);
}


static void _dbus_dbus_service_iintrospectable_Introspect_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar* result;
	invocation = _user_data_;
	result = dbus_service_iintrospectable_Introspect_finish ((DBusServiceIIntrospectable*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_string (result));
	_g_free0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void dbus_service_iintrospectable_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	if (strcmp (method_name, "Introspect") == 0) {
		_dbus_dbus_service_iintrospectable_Introspect (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}


static GVariant* dbus_service_iintrospectable_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return NULL;
}


static gboolean dbus_service_iintrospectable_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return FALSE;
}


guint dbus_service_iintrospectable_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
	guint result;
	gpointer *data;
	data = g_new (gpointer, 3);
	data[0] = g_object_ref (object);
	data[1] = g_object_ref (connection);
	data[2] = g_strdup (path);
	result = g_dbus_connection_register_object (connection, path, (GDBusInterfaceInfo *) (&_dbus_service_iintrospectable_dbus_interface_info), &_dbus_service_iintrospectable_dbus_interface_vtable, data, _dbus_service_iintrospectable_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}


static void _dbus_service_iintrospectable_unregister_object (gpointer user_data) {
	gpointer* data;
	data = user_data;
	g_object_unref (data[0]);
	g_object_unref (data[1]);
	g_free (data[2]);
	g_free (data);
}


void dbus_service_iproperties_Get (DBusServiceIProperties* self, const gchar* iface, const gchar* prop, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_IPROPERTIES_GET_INTERFACE (self)->Get (self, iface, prop, _callback_, _user_data_);
}


GVariant* dbus_service_iproperties_Get_finish (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error) {
	return DBUS_SERVICE_IPROPERTIES_GET_INTERFACE (self)->Get_finish (self, _res_, error);
}


void dbus_service_iproperties_Set (DBusServiceIProperties* self, const gchar* iface, const gchar* prop, GVariant* val, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_IPROPERTIES_GET_INTERFACE (self)->Set (self, iface, prop, val, _callback_, _user_data_);
}


void dbus_service_iproperties_Set_finish (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error) {
	DBUS_SERVICE_IPROPERTIES_GET_INTERFACE (self)->Set_finish (self, _res_, error);
}


void dbus_service_iproperties_GetAll (DBusServiceIProperties* self, const gchar* iface, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_IPROPERTIES_GET_INTERFACE (self)->GetAll (self, iface, _callback_, _user_data_);
}


GHashTable* dbus_service_iproperties_GetAll_finish (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error) {
	return DBUS_SERVICE_IPROPERTIES_GET_INTERFACE (self)->GetAll_finish (self, _res_, error);
}


static void dbus_service_iproperties_base_init (DBusServiceIPropertiesIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
	}
}


GType dbus_service_iproperties_get_type (void) {
	static volatile gsize dbus_service_iproperties_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_service_iproperties_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (DBusServiceIPropertiesIface), (GBaseInitFunc) dbus_service_iproperties_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType dbus_service_iproperties_type_id;
		dbus_service_iproperties_type_id = g_type_register_static (G_TYPE_INTERFACE, "DBusServiceIProperties", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (dbus_service_iproperties_type_id, G_TYPE_OBJECT);
		g_type_set_qdata (dbus_service_iproperties_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) dbus_service_iproperties_proxy_get_type);
		g_type_set_qdata (dbus_service_iproperties_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.freedesktop.DBus.Properties");
		g_type_set_qdata (dbus_service_iproperties_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) dbus_service_iproperties_register_object);
		g_once_init_leave (&dbus_service_iproperties_type_id__volatile, dbus_service_iproperties_type_id);
	}
	return dbus_service_iproperties_type_id__volatile;
}


G_DEFINE_TYPE_EXTENDED (DBusServiceIPropertiesProxy, dbus_service_iproperties_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (DBUS_SERVICE_TYPE_IPROPERTIES, dbus_service_iproperties_proxy_dbus_service_iproperties_interface_init) )
static void dbus_service_iproperties_proxy_class_init (DBusServiceIPropertiesProxyClass* klass) {
	G_DBUS_PROXY_CLASS (klass)->g_signal = dbus_service_iproperties_proxy_g_signal;
}


static void dbus_service_iproperties_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters) {
}


static void dbus_service_iproperties_proxy_init (DBusServiceIPropertiesProxy* self) {
}


static void dbus_service_iproperties_proxy_Get_async (DBusServiceIProperties* self, const gchar* iface, const gchar* prop, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus.Properties", "Get");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (iface));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (prop));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static GVariant* dbus_service_iproperties_proxy_Get_finish (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	GVariant* _result;
	GVariant* _tmp1_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp1_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_variant (_tmp1_);
	g_variant_unref (_tmp1_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_iproperties_proxy_Set_async (DBusServiceIProperties* self, const gchar* iface, const gchar* prop, GVariant* val, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus.Properties", "Set");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (iface));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (prop));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_variant (val));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static void dbus_service_iproperties_proxy_Set_finish (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static void dbus_service_iproperties_proxy_GetAll_async (DBusServiceIProperties* self, const gchar* iface, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus.Properties", "GetAll");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (iface));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static GHashTable* dbus_service_iproperties_proxy_GetAll_finish (DBusServiceIProperties* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	GHashTable* _result;
	GVariant* _tmp2_;
	GHashTable* _tmp3_;
	GVariantIter _tmp4_;
	GVariant* _tmp5_;
	GVariant* _tmp6_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp2_ = g_variant_iter_next_value (&_reply_iter);
	_tmp3_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
	g_variant_iter_init (&_tmp4_, _tmp2_);
	while (g_variant_iter_loop (&_tmp4_, "{?*}", &_tmp5_, &_tmp6_)) {
		g_hash_table_insert (_tmp3_, g_variant_dup_string (_tmp5_, NULL), g_variant_get_variant (_tmp6_));
	}
	_result = _tmp3_;
	g_variant_unref (_tmp2_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_iproperties_proxy_dbus_service_iproperties_interface_init (DBusServiceIPropertiesIface* iface) {
	iface->Get = dbus_service_iproperties_proxy_Get_async;
	iface->Get_finish = dbus_service_iproperties_proxy_Get_finish;
	iface->Set = dbus_service_iproperties_proxy_Set_async;
	iface->Set_finish = dbus_service_iproperties_proxy_Set_finish;
	iface->GetAll = dbus_service_iproperties_proxy_GetAll_async;
	iface->GetAll_finish = dbus_service_iproperties_proxy_GetAll_finish;
}


static void _dbus_dbus_service_iproperties_Get (DBusServiceIProperties* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* iface = NULL;
	GVariant* _tmp7_;
	gchar* prop = NULL;
	GVariant* _tmp8_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp7_ = g_variant_iter_next_value (&_arguments_iter);
	iface = g_variant_dup_string (_tmp7_, NULL);
	g_variant_unref (_tmp7_);
	_tmp8_ = g_variant_iter_next_value (&_arguments_iter);
	prop = g_variant_dup_string (_tmp8_, NULL);
	g_variant_unref (_tmp8_);
	dbus_service_iproperties_Get (self, iface, prop, (GAsyncReadyCallback) _dbus_dbus_service_iproperties_Get_ready, invocation);
	_g_free0 (iface);
	_g_free0 (prop);
}


static void _dbus_dbus_service_iproperties_Get_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	GVariant* result;
	invocation = _user_data_;
	result = dbus_service_iproperties_Get_finish ((DBusServiceIProperties*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_variant (result));
	_g_variant_unref0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_iproperties_Set (DBusServiceIProperties* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* iface = NULL;
	GVariant* _tmp9_;
	gchar* prop = NULL;
	GVariant* _tmp10_;
	GVariant* val = NULL;
	GVariant* _tmp11_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp9_ = g_variant_iter_next_value (&_arguments_iter);
	iface = g_variant_dup_string (_tmp9_, NULL);
	g_variant_unref (_tmp9_);
	_tmp10_ = g_variant_iter_next_value (&_arguments_iter);
	prop = g_variant_dup_string (_tmp10_, NULL);
	g_variant_unref (_tmp10_);
	_tmp11_ = g_variant_iter_next_value (&_arguments_iter);
	val = g_variant_get_variant (_tmp11_);
	g_variant_unref (_tmp11_);
	dbus_service_iproperties_Set (self, iface, prop, val, (GAsyncReadyCallback) _dbus_dbus_service_iproperties_Set_ready, invocation);
	_g_free0 (iface);
	_g_free0 (prop);
	_g_variant_unref0 (val);
}


static void _dbus_dbus_service_iproperties_Set_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	invocation = _user_data_;
	dbus_service_iproperties_Set_finish ((DBusServiceIProperties*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_iproperties_GetAll (DBusServiceIProperties* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* iface = NULL;
	GVariant* _tmp12_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp12_ = g_variant_iter_next_value (&_arguments_iter);
	iface = g_variant_dup_string (_tmp12_, NULL);
	g_variant_unref (_tmp12_);
	dbus_service_iproperties_GetAll (self, iface, (GAsyncReadyCallback) _dbus_dbus_service_iproperties_GetAll_ready, invocation);
	_g_free0 (iface);
}


static void _dbus_dbus_service_iproperties_GetAll_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	GHashTable* result;
	GVariantBuilder _tmp13_;
	GHashTableIter _tmp14_;
	gpointer _tmp15_;
	gpointer _tmp16_;
	invocation = _user_data_;
	result = dbus_service_iproperties_GetAll_finish ((DBusServiceIProperties*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_hash_table_iter_init (&_tmp14_, result);
	g_variant_builder_init (&_tmp13_, G_VARIANT_TYPE ("a{sv}"));
	while (g_hash_table_iter_next (&_tmp14_, &_tmp15_, &_tmp16_)) {
		gchar* _key;
		GVariant* _value;
		_key = (gchar*) _tmp15_;
		_value = (GVariant*) _tmp16_;
		g_variant_builder_add (&_tmp13_, "{?*}", g_variant_new_string (_key), g_variant_new_variant (_value));
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp13_));
	_g_hash_table_unref0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void dbus_service_iproperties_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	if (strcmp (method_name, "Get") == 0) {
		_dbus_dbus_service_iproperties_Get (object, parameters, invocation);
	} else if (strcmp (method_name, "Set") == 0) {
		_dbus_dbus_service_iproperties_Set (object, parameters, invocation);
	} else if (strcmp (method_name, "GetAll") == 0) {
		_dbus_dbus_service_iproperties_GetAll (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}


static GVariant* dbus_service_iproperties_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return NULL;
}


static gboolean dbus_service_iproperties_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return FALSE;
}


guint dbus_service_iproperties_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
	guint result;
	gpointer *data;
	data = g_new (gpointer, 3);
	data[0] = g_object_ref (object);
	data[1] = g_object_ref (connection);
	data[2] = g_strdup (path);
	result = g_dbus_connection_register_object (connection, path, (GDBusInterfaceInfo *) (&_dbus_service_iproperties_dbus_interface_info), &_dbus_service_iproperties_dbus_interface_vtable, data, _dbus_service_iproperties_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}


static void _dbus_service_iproperties_unregister_object (gpointer user_data) {
	gpointer* data;
	data = user_data;
	g_object_unref (data[0]);
	g_object_unref (data[1]);
	g_free (data[2]);
	g_free (data);
}


void dbus_service_ipeer_Ping (DBusServiceIPeer* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_IPEER_GET_INTERFACE (self)->Ping (self, _callback_, _user_data_);
}


void dbus_service_ipeer_Ping_finish (DBusServiceIPeer* self, GAsyncResult* _res_, GError** error) {
	DBUS_SERVICE_IPEER_GET_INTERFACE (self)->Ping_finish (self, _res_, error);
}


static void dbus_service_ipeer_base_init (DBusServiceIPeerIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
	}
}


GType dbus_service_ipeer_get_type (void) {
	static volatile gsize dbus_service_ipeer_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_service_ipeer_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (DBusServiceIPeerIface), (GBaseInitFunc) dbus_service_ipeer_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType dbus_service_ipeer_type_id;
		dbus_service_ipeer_type_id = g_type_register_static (G_TYPE_INTERFACE, "DBusServiceIPeer", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (dbus_service_ipeer_type_id, G_TYPE_OBJECT);
		g_type_set_qdata (dbus_service_ipeer_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) dbus_service_ipeer_proxy_get_type);
		g_type_set_qdata (dbus_service_ipeer_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.freedesktop.DBus.Peer");
		g_type_set_qdata (dbus_service_ipeer_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) dbus_service_ipeer_register_object);
		g_once_init_leave (&dbus_service_ipeer_type_id__volatile, dbus_service_ipeer_type_id);
	}
	return dbus_service_ipeer_type_id__volatile;
}


G_DEFINE_TYPE_EXTENDED (DBusServiceIPeerProxy, dbus_service_ipeer_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (DBUS_SERVICE_TYPE_IPEER, dbus_service_ipeer_proxy_dbus_service_ipeer_interface_init) )
static void dbus_service_ipeer_proxy_class_init (DBusServiceIPeerProxyClass* klass) {
	G_DBUS_PROXY_CLASS (klass)->g_signal = dbus_service_ipeer_proxy_g_signal;
}


static void dbus_service_ipeer_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters) {
}


static void dbus_service_ipeer_proxy_init (DBusServiceIPeerProxy* self) {
}


static void dbus_service_ipeer_proxy_Ping_async (DBusServiceIPeer* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus.Peer", "Ping");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static void dbus_service_ipeer_proxy_Ping_finish (DBusServiceIPeer* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static void dbus_service_ipeer_proxy_dbus_service_ipeer_interface_init (DBusServiceIPeerIface* iface) {
	iface->Ping = dbus_service_ipeer_proxy_Ping_async;
	iface->Ping_finish = dbus_service_ipeer_proxy_Ping_finish;
}


static void _dbus_dbus_service_ipeer_Ping (DBusServiceIPeer* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	g_variant_iter_init (&_arguments_iter, parameters);
	dbus_service_ipeer_Ping (self, (GAsyncReadyCallback) _dbus_dbus_service_ipeer_Ping_ready, invocation);
}


static void _dbus_dbus_service_ipeer_Ping_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	invocation = _user_data_;
	dbus_service_ipeer_Ping_finish ((DBusServiceIPeer*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void dbus_service_ipeer_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	if (strcmp (method_name, "Ping") == 0) {
		_dbus_dbus_service_ipeer_Ping (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}


static GVariant* dbus_service_ipeer_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return NULL;
}


static gboolean dbus_service_ipeer_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return FALSE;
}


guint dbus_service_ipeer_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
	guint result;
	gpointer *data;
	data = g_new (gpointer, 3);
	data[0] = g_object_ref (object);
	data[1] = g_object_ref (connection);
	data[2] = g_strdup (path);
	result = g_dbus_connection_register_object (connection, path, (GDBusInterfaceInfo *) (&_dbus_service_ipeer_dbus_interface_info), &_dbus_service_ipeer_dbus_interface_vtable, data, _dbus_service_ipeer_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}


static void _dbus_service_ipeer_unregister_object (gpointer user_data) {
	gpointer* data;
	data = user_data;
	g_object_unref (data[0]);
	g_object_unref (data[1]);
	g_free (data[2]);
	g_free (data);
}


void dbus_service_id_bus_AddMatch (DBusServiceIDBus* self, const gchar* match, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->AddMatch (self, match, _callback_, _user_data_);
}


void dbus_service_id_bus_AddMatch_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->AddMatch_finish (self, _res_, error);
}


void dbus_service_id_bus_GetAdtAuditSessionData (DBusServiceIDBus* self, const gchar* type, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->GetAdtAuditSessionData (self, type, _callback_, _user_data_);
}


guint8* dbus_service_id_bus_GetAdtAuditSessionData_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->GetAdtAuditSessionData_finish (self, _res_, result_length1, error);
}


void dbus_service_id_bus_GetConnectionSELinuxSecurityContext (DBusServiceIDBus* self, const gchar* type, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->GetConnectionSELinuxSecurityContext (self, type, _callback_, _user_data_);
}


guint8* dbus_service_id_bus_GetConnectionSELinuxSecurityContext_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->GetConnectionSELinuxSecurityContext_finish (self, _res_, result_length1, error);
}


void dbus_service_id_bus_GetConnectionUnixProcessID (DBusServiceIDBus* self, const gchar* conn, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->GetConnectionUnixProcessID (self, conn, _callback_, _user_data_);
}


guint32 dbus_service_id_bus_GetConnectionUnixProcessID_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->GetConnectionUnixProcessID_finish (self, _res_, error);
}


void dbus_service_id_bus_GetConnectionUnixUser (DBusServiceIDBus* self, const gchar* conn, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->GetConnectionUnixUser (self, conn, _callback_, _user_data_);
}


guint32 dbus_service_id_bus_GetConnectionUnixUser_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->GetConnectionUnixUser_finish (self, _res_, error);
}


void dbus_service_id_bus_GetId (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->GetId (self, _callback_, _user_data_);
}


gchar* dbus_service_id_bus_GetId_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->GetId_finish (self, _res_, error);
}


void dbus_service_id_bus_GetNameOwner (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->GetNameOwner (self, name, _callback_, _user_data_);
}


gchar* dbus_service_id_bus_GetNameOwner_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->GetNameOwner_finish (self, _res_, error);
}


void dbus_service_id_bus_Hello (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->Hello (self, _callback_, _user_data_);
}


gchar* dbus_service_id_bus_Hello_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->Hello_finish (self, _res_, error);
}


void dbus_service_id_bus_ListActivatableNames (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->ListActivatableNames (self, _callback_, _user_data_);
}


gchar** dbus_service_id_bus_ListActivatableNames_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->ListActivatableNames_finish (self, _res_, result_length1, error);
}


void dbus_service_id_bus_ListNames (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->ListNames (self, _callback_, _user_data_);
}


gchar** dbus_service_id_bus_ListNames_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->ListNames_finish (self, _res_, result_length1, error);
}


void dbus_service_id_bus_ListQueuedOwners (DBusServiceIDBus* self, const gchar* None, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->ListQueuedOwners (self, None, _callback_, _user_data_);
}


gchar** dbus_service_id_bus_ListQueuedOwners_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->ListQueuedOwners_finish (self, _res_, result_length1, error);
}


void dbus_service_id_bus_NameHasOwner (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->NameHasOwner (self, name, _callback_, _user_data_);
}


gboolean dbus_service_id_bus_NameHasOwner_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->NameHasOwner_finish (self, _res_, error);
}


void dbus_service_id_bus_ReleaseName (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->ReleaseName (self, name, _callback_, _user_data_);
}


guint32 dbus_service_id_bus_ReleaseName_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->ReleaseName_finish (self, _res_, error);
}


void dbus_service_id_bus_ReloadConfig (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->ReloadConfig (self, _callback_, _user_data_);
}


void dbus_service_id_bus_ReloadConfig_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->ReloadConfig_finish (self, _res_, error);
}


void dbus_service_id_bus_RemoveMatch (DBusServiceIDBus* self, const gchar* match, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->RemoveMatch (self, match, _callback_, _user_data_);
}


void dbus_service_id_bus_RemoveMatch_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->RemoveMatch_finish (self, _res_, error);
}


void dbus_service_id_bus_RequestName (DBusServiceIDBus* self, const gchar* name, guint32 flags, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->RequestName (self, name, flags, _callback_, _user_data_);
}


guint32 dbus_service_id_bus_RequestName_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->RequestName_finish (self, _res_, error);
}


void dbus_service_id_bus_StartServiceByName (DBusServiceIDBus* self, const gchar* name, guint32 flags, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->StartServiceByName (self, name, flags, _callback_, _user_data_);
}


guint32 dbus_service_id_bus_StartServiceByName_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	return DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->StartServiceByName_finish (self, _res_, error);
}


void dbus_service_id_bus_UpdateActivationEnvironment (DBusServiceIDBus* self, GHashTable* environment, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->UpdateActivationEnvironment (self, environment, _callback_, _user_data_);
}


void dbus_service_id_bus_UpdateActivationEnvironment_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	DBUS_SERVICE_ID_BUS_GET_INTERFACE (self)->UpdateActivationEnvironment_finish (self, _res_, error);
}


static void g_cclosure_user_marshal_VOID__STRING_STRING_STRING (GClosure * closure, GValue * return_value, guint n_param_values, const GValue * param_values, gpointer invocation_hint, gpointer marshal_data) {
	typedef void (*GMarshalFunc_VOID__STRING_STRING_STRING) (gpointer data1, const char* arg_1, const char* arg_2, const char* arg_3, gpointer data2);
	register GMarshalFunc_VOID__STRING_STRING_STRING callback;
	register GCClosure * cc;
	register gpointer data1;
	register gpointer data2;
	cc = (GCClosure *) closure;
	g_return_if_fail (n_param_values == 4);
	if (G_CCLOSURE_SWAP_DATA (closure)) {
		data1 = closure->data;
		data2 = param_values->data[0].v_pointer;
	} else {
		data1 = param_values->data[0].v_pointer;
		data2 = closure->data;
	}
	callback = (GMarshalFunc_VOID__STRING_STRING_STRING) (marshal_data ? marshal_data : cc->callback);
	callback (data1, g_value_get_string (param_values + 1), g_value_get_string (param_values + 2), g_value_get_string (param_values + 3), data2);
}


static void dbus_service_id_bus_base_init (DBusServiceIDBusIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
		g_signal_new ("name_acquired", DBUS_SERVICE_TYPE_ID_BUS, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
		g_signal_new ("name_lost", DBUS_SERVICE_TYPE_ID_BUS, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
		g_signal_new ("name_owner_changed", DBUS_SERVICE_TYPE_ID_BUS, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_STRING_STRING, G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
	}
}


GType dbus_service_id_bus_get_type (void) {
	static volatile gsize dbus_service_id_bus_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_service_id_bus_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (DBusServiceIDBusIface), (GBaseInitFunc) dbus_service_id_bus_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType dbus_service_id_bus_type_id;
		dbus_service_id_bus_type_id = g_type_register_static (G_TYPE_INTERFACE, "DBusServiceIDBus", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (dbus_service_id_bus_type_id, G_TYPE_OBJECT);
		g_type_set_qdata (dbus_service_id_bus_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) dbus_service_id_bus_proxy_get_type);
		g_type_set_qdata (dbus_service_id_bus_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.freedesktop.DBus");
		g_type_set_qdata (dbus_service_id_bus_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) dbus_service_id_bus_register_object);
		g_once_init_leave (&dbus_service_id_bus_type_id__volatile, dbus_service_id_bus_type_id);
	}
	return dbus_service_id_bus_type_id__volatile;
}


G_DEFINE_TYPE_EXTENDED (DBusServiceIDBusProxy, dbus_service_id_bus_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (DBUS_SERVICE_TYPE_ID_BUS, dbus_service_id_bus_proxy_dbus_service_id_bus_interface_init) )
static void dbus_service_id_bus_proxy_class_init (DBusServiceIDBusProxyClass* klass) {
	G_DBUS_PROXY_CLASS (klass)->g_signal = dbus_service_id_bus_proxy_g_signal;
}


static void _dbus_handle_dbus_service_id_bus_name_acquired (DBusServiceIDBus* self, GVariant* parameters) {
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp17_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp17_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp17_, NULL);
	g_variant_unref (_tmp17_);
	g_signal_emit_by_name (self, "name-acquired", name);
	_g_free0 (name);
}


static void _dbus_handle_dbus_service_id_bus_name_lost (DBusServiceIDBus* self, GVariant* parameters) {
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp18_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp18_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp18_, NULL);
	g_variant_unref (_tmp18_);
	g_signal_emit_by_name (self, "name-lost", name);
	_g_free0 (name);
}


static void _dbus_handle_dbus_service_id_bus_name_owner_changed (DBusServiceIDBus* self, GVariant* parameters) {
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp19_;
	gchar* oldowner = NULL;
	GVariant* _tmp20_;
	gchar* newowner = NULL;
	GVariant* _tmp21_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp19_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp19_, NULL);
	g_variant_unref (_tmp19_);
	_tmp20_ = g_variant_iter_next_value (&_arguments_iter);
	oldowner = g_variant_dup_string (_tmp20_, NULL);
	g_variant_unref (_tmp20_);
	_tmp21_ = g_variant_iter_next_value (&_arguments_iter);
	newowner = g_variant_dup_string (_tmp21_, NULL);
	g_variant_unref (_tmp21_);
	g_signal_emit_by_name (self, "name-owner-changed", name, oldowner, newowner);
	_g_free0 (name);
	_g_free0 (oldowner);
	_g_free0 (newowner);
}


static void dbus_service_id_bus_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters) {
	if (strcmp (signal_name, "NameAcquired") == 0) {
		_dbus_handle_dbus_service_id_bus_name_acquired ((DBusServiceIDBus*) proxy, parameters);
	} else if (strcmp (signal_name, "NameLost") == 0) {
		_dbus_handle_dbus_service_id_bus_name_lost ((DBusServiceIDBus*) proxy, parameters);
	} else if (strcmp (signal_name, "NameOwnerChanged") == 0) {
		_dbus_handle_dbus_service_id_bus_name_owner_changed ((DBusServiceIDBus*) proxy, parameters);
	}
}


static void dbus_service_id_bus_proxy_init (DBusServiceIDBusProxy* self) {
}


static void dbus_service_id_bus_proxy_AddMatch_async (DBusServiceIDBus* self, const gchar* match, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "AddMatch");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (match));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static void dbus_service_id_bus_proxy_AddMatch_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static void dbus_service_id_bus_proxy_GetAdtAuditSessionData_async (DBusServiceIDBus* self, const gchar* type, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetAdtAuditSessionData");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (type));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static guint8* dbus_service_id_bus_proxy_GetAdtAuditSessionData_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint8* _result;
	int _result_length1;
	GVariant* _tmp22_;
	guint8* _tmp23_;
	int _tmp23__length;
	int _tmp23__size;
	int _tmp23__length1;
	GVariantIter _tmp24_;
	GVariant* _tmp25_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp22_ = g_variant_iter_next_value (&_reply_iter);
	_tmp23_ = g_new (guint8, 5);
	_tmp23__length = 0;
	_tmp23__size = 4;
	_tmp23__length1 = 0;
	g_variant_iter_init (&_tmp24_, _tmp22_);
	for (; (_tmp25_ = g_variant_iter_next_value (&_tmp24_)) != NULL; _tmp23__length1++) {
		if (_tmp23__size == _tmp23__length) {
			_tmp23__size = 2 * _tmp23__size;
			_tmp23_ = g_renew (guint8, _tmp23_, _tmp23__size + 1);
		}
		_tmp23_[_tmp23__length++] = g_variant_get_byte (_tmp25_);
		g_variant_unref (_tmp25_);
	}
	_result_length1 = _tmp23__length1;
	_result = _tmp23_;
	g_variant_unref (_tmp22_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_GetConnectionSELinuxSecurityContext_async (DBusServiceIDBus* self, const gchar* type, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetConnectionSELinuxSecurityContext");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (type));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static guint8* dbus_service_id_bus_proxy_GetConnectionSELinuxSecurityContext_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint8* _result;
	int _result_length1;
	GVariant* _tmp26_;
	guint8* _tmp27_;
	int _tmp27__length;
	int _tmp27__size;
	int _tmp27__length1;
	GVariantIter _tmp28_;
	GVariant* _tmp29_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp26_ = g_variant_iter_next_value (&_reply_iter);
	_tmp27_ = g_new (guint8, 5);
	_tmp27__length = 0;
	_tmp27__size = 4;
	_tmp27__length1 = 0;
	g_variant_iter_init (&_tmp28_, _tmp26_);
	for (; (_tmp29_ = g_variant_iter_next_value (&_tmp28_)) != NULL; _tmp27__length1++) {
		if (_tmp27__size == _tmp27__length) {
			_tmp27__size = 2 * _tmp27__size;
			_tmp27_ = g_renew (guint8, _tmp27_, _tmp27__size + 1);
		}
		_tmp27_[_tmp27__length++] = g_variant_get_byte (_tmp29_);
		g_variant_unref (_tmp29_);
	}
	_result_length1 = _tmp27__length1;
	_result = _tmp27_;
	g_variant_unref (_tmp26_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_GetConnectionUnixProcessID_async (DBusServiceIDBus* self, const gchar* conn, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetConnectionUnixProcessID");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (conn));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static guint32 dbus_service_id_bus_proxy_GetConnectionUnixProcessID_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint32 _result;
	GVariant* _tmp30_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp30_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp30_);
	g_variant_unref (_tmp30_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_GetConnectionUnixUser_async (DBusServiceIDBus* self, const gchar* conn, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetConnectionUnixUser");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (conn));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static guint32 dbus_service_id_bus_proxy_GetConnectionUnixUser_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint32 _result;
	GVariant* _tmp31_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp31_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp31_);
	g_variant_unref (_tmp31_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_GetId_async (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetId");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static gchar* dbus_service_id_bus_proxy_GetId_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar* _result;
	GVariant* _tmp32_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp32_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_dup_string (_tmp32_, NULL);
	g_variant_unref (_tmp32_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_GetNameOwner_async (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetNameOwner");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static gchar* dbus_service_id_bus_proxy_GetNameOwner_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar* _result;
	GVariant* _tmp33_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp33_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_dup_string (_tmp33_, NULL);
	g_variant_unref (_tmp33_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_Hello_async (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "Hello");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static gchar* dbus_service_id_bus_proxy_Hello_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar* _result;
	GVariant* _tmp34_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp34_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_dup_string (_tmp34_, NULL);
	g_variant_unref (_tmp34_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_ListActivatableNames_async (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ListActivatableNames");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static gchar** dbus_service_id_bus_proxy_ListActivatableNames_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar** _result;
	int _result_length1;
	GVariant* _tmp35_;
	gchar** _tmp36_;
	int _tmp36__length;
	int _tmp36__size;
	int _tmp36__length1;
	GVariantIter _tmp37_;
	GVariant* _tmp38_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp35_ = g_variant_iter_next_value (&_reply_iter);
	_tmp36_ = g_new (gchar*, 5);
	_tmp36__length = 0;
	_tmp36__size = 4;
	_tmp36__length1 = 0;
	g_variant_iter_init (&_tmp37_, _tmp35_);
	for (; (_tmp38_ = g_variant_iter_next_value (&_tmp37_)) != NULL; _tmp36__length1++) {
		if (_tmp36__size == _tmp36__length) {
			_tmp36__size = 2 * _tmp36__size;
			_tmp36_ = g_renew (gchar*, _tmp36_, _tmp36__size + 1);
		}
		_tmp36_[_tmp36__length++] = g_variant_dup_string (_tmp38_, NULL);
		g_variant_unref (_tmp38_);
	}
	_result_length1 = _tmp36__length1;
	_tmp36_[_tmp36__length] = NULL;
	_result = _tmp36_;
	g_variant_unref (_tmp35_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_ListNames_async (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ListNames");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static gchar** dbus_service_id_bus_proxy_ListNames_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar** _result;
	int _result_length1;
	GVariant* _tmp39_;
	gchar** _tmp40_;
	int _tmp40__length;
	int _tmp40__size;
	int _tmp40__length1;
	GVariantIter _tmp41_;
	GVariant* _tmp42_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp39_ = g_variant_iter_next_value (&_reply_iter);
	_tmp40_ = g_new (gchar*, 5);
	_tmp40__length = 0;
	_tmp40__size = 4;
	_tmp40__length1 = 0;
	g_variant_iter_init (&_tmp41_, _tmp39_);
	for (; (_tmp42_ = g_variant_iter_next_value (&_tmp41_)) != NULL; _tmp40__length1++) {
		if (_tmp40__size == _tmp40__length) {
			_tmp40__size = 2 * _tmp40__size;
			_tmp40_ = g_renew (gchar*, _tmp40_, _tmp40__size + 1);
		}
		_tmp40_[_tmp40__length++] = g_variant_dup_string (_tmp42_, NULL);
		g_variant_unref (_tmp42_);
	}
	_result_length1 = _tmp40__length1;
	_tmp40_[_tmp40__length] = NULL;
	_result = _tmp40_;
	g_variant_unref (_tmp39_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_ListQueuedOwners_async (DBusServiceIDBus* self, const gchar* None, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ListQueuedOwners");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (None));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static gchar** dbus_service_id_bus_proxy_ListQueuedOwners_finish (DBusServiceIDBus* self, GAsyncResult* _res_, int* result_length1, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar** _result;
	int _result_length1;
	GVariant* _tmp43_;
	gchar** _tmp44_;
	int _tmp44__length;
	int _tmp44__size;
	int _tmp44__length1;
	GVariantIter _tmp45_;
	GVariant* _tmp46_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp43_ = g_variant_iter_next_value (&_reply_iter);
	_tmp44_ = g_new (gchar*, 5);
	_tmp44__length = 0;
	_tmp44__size = 4;
	_tmp44__length1 = 0;
	g_variant_iter_init (&_tmp45_, _tmp43_);
	for (; (_tmp46_ = g_variant_iter_next_value (&_tmp45_)) != NULL; _tmp44__length1++) {
		if (_tmp44__size == _tmp44__length) {
			_tmp44__size = 2 * _tmp44__size;
			_tmp44_ = g_renew (gchar*, _tmp44_, _tmp44__size + 1);
		}
		_tmp44_[_tmp44__length++] = g_variant_dup_string (_tmp46_, NULL);
		g_variant_unref (_tmp46_);
	}
	_result_length1 = _tmp44__length1;
	_tmp44_[_tmp44__length] = NULL;
	_result = _tmp44_;
	g_variant_unref (_tmp43_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_NameHasOwner_async (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "NameHasOwner");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static gboolean dbus_service_id_bus_proxy_NameHasOwner_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gboolean _result;
	GVariant* _tmp47_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return FALSE;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return FALSE;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp47_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_boolean (_tmp47_);
	g_variant_unref (_tmp47_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_ReleaseName_async (DBusServiceIDBus* self, const gchar* name, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ReleaseName");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static guint32 dbus_service_id_bus_proxy_ReleaseName_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint32 _result;
	GVariant* _tmp48_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp48_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp48_);
	g_variant_unref (_tmp48_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_ReloadConfig_async (DBusServiceIDBus* self, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ReloadConfig");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static void dbus_service_id_bus_proxy_ReloadConfig_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static void dbus_service_id_bus_proxy_RemoveMatch_async (DBusServiceIDBus* self, const gchar* match, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "RemoveMatch");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (match));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static void dbus_service_id_bus_proxy_RemoveMatch_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static void dbus_service_id_bus_proxy_RequestName_async (DBusServiceIDBus* self, const gchar* name, guint32 flags, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "RequestName");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (flags));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static guint32 dbus_service_id_bus_proxy_RequestName_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint32 _result;
	GVariant* _tmp49_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp49_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp49_);
	g_variant_unref (_tmp49_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_StartServiceByName_async (DBusServiceIDBus* self, const gchar* name, guint32 flags, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "StartServiceByName");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (flags));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static guint32 dbus_service_id_bus_proxy_StartServiceByName_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint32 _result;
	GVariant* _tmp50_;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp50_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp50_);
	g_variant_unref (_tmp50_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_proxy_UpdateActivationEnvironment_async (DBusServiceIDBus* self, GHashTable* environment, GAsyncReadyCallback _callback_, gpointer _user_data_) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GVariantBuilder _tmp51_;
	GHashTableIter _tmp52_;
	gpointer _tmp53_;
	gpointer _tmp54_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "UpdateActivationEnvironment");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_hash_table_iter_init (&_tmp52_, environment);
	g_variant_builder_init (&_tmp51_, G_VARIANT_TYPE ("a{ss}"));
	while (g_hash_table_iter_next (&_tmp52_, &_tmp53_, &_tmp54_)) {
		gchar* _key;
		gchar* _value;
		_key = (gchar*) _tmp53_;
		_value = (gchar*) _tmp54_;
		g_variant_builder_add (&_tmp51_, "{?*}", g_variant_new_string (_key), g_variant_new_string (_value));
	}
	g_variant_builder_add_value (&_arguments_builder, g_variant_builder_end (&_tmp51_));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	g_dbus_connection_send_message_with_reply (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, _vala_g_async_ready_callback, g_simple_async_result_new ((GObject *) self, _callback_, _user_data_, NULL));
	g_object_unref (_message);
}


static void dbus_service_id_bus_proxy_UpdateActivationEnvironment_finish (DBusServiceIDBus* self, GAsyncResult* _res_, GError** error) {
	GDBusMessage *_reply_message;
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), g_simple_async_result_get_op_res_gpointer ((GSimpleAsyncResult *) _res_), error);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static void dbus_service_id_bus_proxy_dbus_service_id_bus_interface_init (DBusServiceIDBusIface* iface) {
	iface->AddMatch = dbus_service_id_bus_proxy_AddMatch_async;
	iface->AddMatch_finish = dbus_service_id_bus_proxy_AddMatch_finish;
	iface->GetAdtAuditSessionData = dbus_service_id_bus_proxy_GetAdtAuditSessionData_async;
	iface->GetAdtAuditSessionData_finish = dbus_service_id_bus_proxy_GetAdtAuditSessionData_finish;
	iface->GetConnectionSELinuxSecurityContext = dbus_service_id_bus_proxy_GetConnectionSELinuxSecurityContext_async;
	iface->GetConnectionSELinuxSecurityContext_finish = dbus_service_id_bus_proxy_GetConnectionSELinuxSecurityContext_finish;
	iface->GetConnectionUnixProcessID = dbus_service_id_bus_proxy_GetConnectionUnixProcessID_async;
	iface->GetConnectionUnixProcessID_finish = dbus_service_id_bus_proxy_GetConnectionUnixProcessID_finish;
	iface->GetConnectionUnixUser = dbus_service_id_bus_proxy_GetConnectionUnixUser_async;
	iface->GetConnectionUnixUser_finish = dbus_service_id_bus_proxy_GetConnectionUnixUser_finish;
	iface->GetId = dbus_service_id_bus_proxy_GetId_async;
	iface->GetId_finish = dbus_service_id_bus_proxy_GetId_finish;
	iface->GetNameOwner = dbus_service_id_bus_proxy_GetNameOwner_async;
	iface->GetNameOwner_finish = dbus_service_id_bus_proxy_GetNameOwner_finish;
	iface->Hello = dbus_service_id_bus_proxy_Hello_async;
	iface->Hello_finish = dbus_service_id_bus_proxy_Hello_finish;
	iface->ListActivatableNames = dbus_service_id_bus_proxy_ListActivatableNames_async;
	iface->ListActivatableNames_finish = dbus_service_id_bus_proxy_ListActivatableNames_finish;
	iface->ListNames = dbus_service_id_bus_proxy_ListNames_async;
	iface->ListNames_finish = dbus_service_id_bus_proxy_ListNames_finish;
	iface->ListQueuedOwners = dbus_service_id_bus_proxy_ListQueuedOwners_async;
	iface->ListQueuedOwners_finish = dbus_service_id_bus_proxy_ListQueuedOwners_finish;
	iface->NameHasOwner = dbus_service_id_bus_proxy_NameHasOwner_async;
	iface->NameHasOwner_finish = dbus_service_id_bus_proxy_NameHasOwner_finish;
	iface->ReleaseName = dbus_service_id_bus_proxy_ReleaseName_async;
	iface->ReleaseName_finish = dbus_service_id_bus_proxy_ReleaseName_finish;
	iface->ReloadConfig = dbus_service_id_bus_proxy_ReloadConfig_async;
	iface->ReloadConfig_finish = dbus_service_id_bus_proxy_ReloadConfig_finish;
	iface->RemoveMatch = dbus_service_id_bus_proxy_RemoveMatch_async;
	iface->RemoveMatch_finish = dbus_service_id_bus_proxy_RemoveMatch_finish;
	iface->RequestName = dbus_service_id_bus_proxy_RequestName_async;
	iface->RequestName_finish = dbus_service_id_bus_proxy_RequestName_finish;
	iface->StartServiceByName = dbus_service_id_bus_proxy_StartServiceByName_async;
	iface->StartServiceByName_finish = dbus_service_id_bus_proxy_StartServiceByName_finish;
	iface->UpdateActivationEnvironment = dbus_service_id_bus_proxy_UpdateActivationEnvironment_async;
	iface->UpdateActivationEnvironment_finish = dbus_service_id_bus_proxy_UpdateActivationEnvironment_finish;
}


static void _dbus_dbus_service_id_bus_AddMatch (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* match = NULL;
	GVariant* _tmp55_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp55_ = g_variant_iter_next_value (&_arguments_iter);
	match = g_variant_dup_string (_tmp55_, NULL);
	g_variant_unref (_tmp55_);
	dbus_service_id_bus_AddMatch (self, match, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_AddMatch_ready, invocation);
	_g_free0 (match);
}


static void _dbus_dbus_service_id_bus_AddMatch_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	invocation = _user_data_;
	dbus_service_id_bus_AddMatch_finish ((DBusServiceIDBus*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_GetAdtAuditSessionData (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* type = NULL;
	GVariant* _tmp56_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp56_ = g_variant_iter_next_value (&_arguments_iter);
	type = g_variant_dup_string (_tmp56_, NULL);
	g_variant_unref (_tmp56_);
	dbus_service_id_bus_GetAdtAuditSessionData (self, type, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_GetAdtAuditSessionData_ready, invocation);
	_g_free0 (type);
}


static void _dbus_dbus_service_id_bus_GetAdtAuditSessionData_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint8* result;
	int result_length1 = 0;
	guint8* _tmp57_;
	GVariantBuilder _tmp58_;
	int _tmp59_;
	invocation = _user_data_;
	result = dbus_service_id_bus_GetAdtAuditSessionData_finish ((DBusServiceIDBus*) source_object, _res_, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp57_ = result;
	g_variant_builder_init (&_tmp58_, G_VARIANT_TYPE ("ay"));
	for (_tmp59_ = 0; _tmp59_ < result_length1; _tmp59_++) {
		g_variant_builder_add_value (&_tmp58_, g_variant_new_byte (*_tmp57_));
		_tmp57_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp58_));
	result = (g_free (result), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_GetConnectionSELinuxSecurityContext (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* type = NULL;
	GVariant* _tmp60_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp60_ = g_variant_iter_next_value (&_arguments_iter);
	type = g_variant_dup_string (_tmp60_, NULL);
	g_variant_unref (_tmp60_);
	dbus_service_id_bus_GetConnectionSELinuxSecurityContext (self, type, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_GetConnectionSELinuxSecurityContext_ready, invocation);
	_g_free0 (type);
}


static void _dbus_dbus_service_id_bus_GetConnectionSELinuxSecurityContext_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint8* result;
	int result_length1 = 0;
	guint8* _tmp61_;
	GVariantBuilder _tmp62_;
	int _tmp63_;
	invocation = _user_data_;
	result = dbus_service_id_bus_GetConnectionSELinuxSecurityContext_finish ((DBusServiceIDBus*) source_object, _res_, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp61_ = result;
	g_variant_builder_init (&_tmp62_, G_VARIANT_TYPE ("ay"));
	for (_tmp63_ = 0; _tmp63_ < result_length1; _tmp63_++) {
		g_variant_builder_add_value (&_tmp62_, g_variant_new_byte (*_tmp61_));
		_tmp61_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp62_));
	result = (g_free (result), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_GetConnectionUnixProcessID (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* conn = NULL;
	GVariant* _tmp64_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp64_ = g_variant_iter_next_value (&_arguments_iter);
	conn = g_variant_dup_string (_tmp64_, NULL);
	g_variant_unref (_tmp64_);
	dbus_service_id_bus_GetConnectionUnixProcessID (self, conn, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_GetConnectionUnixProcessID_ready, invocation);
	_g_free0 (conn);
}


static void _dbus_dbus_service_id_bus_GetConnectionUnixProcessID_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint32 result;
	invocation = _user_data_;
	result = dbus_service_id_bus_GetConnectionUnixProcessID_finish ((DBusServiceIDBus*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_GetConnectionUnixUser (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* conn = NULL;
	GVariant* _tmp65_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp65_ = g_variant_iter_next_value (&_arguments_iter);
	conn = g_variant_dup_string (_tmp65_, NULL);
	g_variant_unref (_tmp65_);
	dbus_service_id_bus_GetConnectionUnixUser (self, conn, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_GetConnectionUnixUser_ready, invocation);
	_g_free0 (conn);
}


static void _dbus_dbus_service_id_bus_GetConnectionUnixUser_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint32 result;
	invocation = _user_data_;
	result = dbus_service_id_bus_GetConnectionUnixUser_finish ((DBusServiceIDBus*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_GetId (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	g_variant_iter_init (&_arguments_iter, parameters);
	dbus_service_id_bus_GetId (self, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_GetId_ready, invocation);
}


static void _dbus_dbus_service_id_bus_GetId_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar* result;
	invocation = _user_data_;
	result = dbus_service_id_bus_GetId_finish ((DBusServiceIDBus*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_string (result));
	_g_free0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_GetNameOwner (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp66_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp66_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp66_, NULL);
	g_variant_unref (_tmp66_);
	dbus_service_id_bus_GetNameOwner (self, name, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_GetNameOwner_ready, invocation);
	_g_free0 (name);
}


static void _dbus_dbus_service_id_bus_GetNameOwner_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar* result;
	invocation = _user_data_;
	result = dbus_service_id_bus_GetNameOwner_finish ((DBusServiceIDBus*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_string (result));
	_g_free0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_Hello (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	g_variant_iter_init (&_arguments_iter, parameters);
	dbus_service_id_bus_Hello (self, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_Hello_ready, invocation);
}


static void _dbus_dbus_service_id_bus_Hello_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar* result;
	invocation = _user_data_;
	result = dbus_service_id_bus_Hello_finish ((DBusServiceIDBus*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_string (result));
	_g_free0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_ListActivatableNames (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	g_variant_iter_init (&_arguments_iter, parameters);
	dbus_service_id_bus_ListActivatableNames (self, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_ListActivatableNames_ready, invocation);
}


static void _dbus_dbus_service_id_bus_ListActivatableNames_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar** result;
	int result_length1 = 0;
	gchar** _tmp67_;
	GVariantBuilder _tmp68_;
	int _tmp69_;
	invocation = _user_data_;
	result = dbus_service_id_bus_ListActivatableNames_finish ((DBusServiceIDBus*) source_object, _res_, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp67_ = result;
	g_variant_builder_init (&_tmp68_, G_VARIANT_TYPE ("as"));
	for (_tmp69_ = 0; _tmp69_ < result_length1; _tmp69_++) {
		g_variant_builder_add_value (&_tmp68_, g_variant_new_string (*_tmp67_));
		_tmp67_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp68_));
	result = (_vala_array_free (result, result_length1, (GDestroyNotify) g_free), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_ListNames (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	g_variant_iter_init (&_arguments_iter, parameters);
	dbus_service_id_bus_ListNames (self, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_ListNames_ready, invocation);
}


static void _dbus_dbus_service_id_bus_ListNames_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar** result;
	int result_length1 = 0;
	gchar** _tmp70_;
	GVariantBuilder _tmp71_;
	int _tmp72_;
	invocation = _user_data_;
	result = dbus_service_id_bus_ListNames_finish ((DBusServiceIDBus*) source_object, _res_, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp70_ = result;
	g_variant_builder_init (&_tmp71_, G_VARIANT_TYPE ("as"));
	for (_tmp72_ = 0; _tmp72_ < result_length1; _tmp72_++) {
		g_variant_builder_add_value (&_tmp71_, g_variant_new_string (*_tmp70_));
		_tmp70_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp71_));
	result = (_vala_array_free (result, result_length1, (GDestroyNotify) g_free), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_ListQueuedOwners (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* None = NULL;
	GVariant* _tmp73_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp73_ = g_variant_iter_next_value (&_arguments_iter);
	None = g_variant_dup_string (_tmp73_, NULL);
	g_variant_unref (_tmp73_);
	dbus_service_id_bus_ListQueuedOwners (self, None, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_ListQueuedOwners_ready, invocation);
	_g_free0 (None);
}


static void _dbus_dbus_service_id_bus_ListQueuedOwners_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar** result;
	int result_length1 = 0;
	gchar** _tmp74_;
	GVariantBuilder _tmp75_;
	int _tmp76_;
	invocation = _user_data_;
	result = dbus_service_id_bus_ListQueuedOwners_finish ((DBusServiceIDBus*) source_object, _res_, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp74_ = result;
	g_variant_builder_init (&_tmp75_, G_VARIANT_TYPE ("as"));
	for (_tmp76_ = 0; _tmp76_ < result_length1; _tmp76_++) {
		g_variant_builder_add_value (&_tmp75_, g_variant_new_string (*_tmp74_));
		_tmp74_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp75_));
	result = (_vala_array_free (result, result_length1, (GDestroyNotify) g_free), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_NameHasOwner (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp77_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp77_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp77_, NULL);
	g_variant_unref (_tmp77_);
	dbus_service_id_bus_NameHasOwner (self, name, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_NameHasOwner_ready, invocation);
	_g_free0 (name);
}


static void _dbus_dbus_service_id_bus_NameHasOwner_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gboolean result;
	invocation = _user_data_;
	result = dbus_service_id_bus_NameHasOwner_finish ((DBusServiceIDBus*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_ReleaseName (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp78_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp78_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp78_, NULL);
	g_variant_unref (_tmp78_);
	dbus_service_id_bus_ReleaseName (self, name, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_ReleaseName_ready, invocation);
	_g_free0 (name);
}


static void _dbus_dbus_service_id_bus_ReleaseName_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint32 result;
	invocation = _user_data_;
	result = dbus_service_id_bus_ReleaseName_finish ((DBusServiceIDBus*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_ReloadConfig (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	g_variant_iter_init (&_arguments_iter, parameters);
	dbus_service_id_bus_ReloadConfig (self, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_ReloadConfig_ready, invocation);
}


static void _dbus_dbus_service_id_bus_ReloadConfig_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	invocation = _user_data_;
	dbus_service_id_bus_ReloadConfig_finish ((DBusServiceIDBus*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_RemoveMatch (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* match = NULL;
	GVariant* _tmp79_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp79_ = g_variant_iter_next_value (&_arguments_iter);
	match = g_variant_dup_string (_tmp79_, NULL);
	g_variant_unref (_tmp79_);
	dbus_service_id_bus_RemoveMatch (self, match, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_RemoveMatch_ready, invocation);
	_g_free0 (match);
}


static void _dbus_dbus_service_id_bus_RemoveMatch_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	invocation = _user_data_;
	dbus_service_id_bus_RemoveMatch_finish ((DBusServiceIDBus*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_RequestName (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp80_;
	guint32 flags = 0U;
	GVariant* _tmp81_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp80_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp80_, NULL);
	g_variant_unref (_tmp80_);
	_tmp81_ = g_variant_iter_next_value (&_arguments_iter);
	flags = g_variant_get_uint32 (_tmp81_);
	g_variant_unref (_tmp81_);
	dbus_service_id_bus_RequestName (self, name, flags, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_RequestName_ready, invocation);
	_g_free0 (name);
}


static void _dbus_dbus_service_id_bus_RequestName_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint32 result;
	invocation = _user_data_;
	result = dbus_service_id_bus_RequestName_finish ((DBusServiceIDBus*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_StartServiceByName (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp82_;
	guint32 flags = 0U;
	GVariant* _tmp83_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp82_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp82_, NULL);
	g_variant_unref (_tmp82_);
	_tmp83_ = g_variant_iter_next_value (&_arguments_iter);
	flags = g_variant_get_uint32 (_tmp83_);
	g_variant_unref (_tmp83_);
	dbus_service_id_bus_StartServiceByName (self, name, flags, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_StartServiceByName_ready, invocation);
	_g_free0 (name);
}


static void _dbus_dbus_service_id_bus_StartServiceByName_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint32 result;
	invocation = _user_data_;
	result = dbus_service_id_bus_StartServiceByName_finish ((DBusServiceIDBus*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_UpdateActivationEnvironment (DBusServiceIDBus* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GVariantIter _arguments_iter;
	GHashTable* environment = NULL;
	GVariant* _tmp84_;
	GHashTable* _tmp85_;
	GVariantIter _tmp86_;
	GVariant* _tmp87_;
	GVariant* _tmp88_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp84_ = g_variant_iter_next_value (&_arguments_iter);
	_tmp85_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
	g_variant_iter_init (&_tmp86_, _tmp84_);
	while (g_variant_iter_loop (&_tmp86_, "{?*}", &_tmp87_, &_tmp88_)) {
		g_hash_table_insert (_tmp85_, g_variant_dup_string (_tmp87_, NULL), g_variant_dup_string (_tmp88_, NULL));
	}
	environment = _tmp85_;
	g_variant_unref (_tmp84_);
	dbus_service_id_bus_UpdateActivationEnvironment (self, environment, (GAsyncReadyCallback) _dbus_dbus_service_id_bus_UpdateActivationEnvironment_ready, invocation);
	_g_hash_table_unref0 (environment);
}


static void _dbus_dbus_service_id_bus_UpdateActivationEnvironment_ready (GObject * source_object, GAsyncResult * _res_, gpointer _user_data_) {
	GDBusMethodInvocation * invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	invocation = _user_data_;
	dbus_service_id_bus_UpdateActivationEnvironment_finish ((DBusServiceIDBus*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void dbus_service_id_bus_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	if (strcmp (method_name, "AddMatch") == 0) {
		_dbus_dbus_service_id_bus_AddMatch (object, parameters, invocation);
	} else if (strcmp (method_name, "GetAdtAuditSessionData") == 0) {
		_dbus_dbus_service_id_bus_GetAdtAuditSessionData (object, parameters, invocation);
	} else if (strcmp (method_name, "GetConnectionSELinuxSecurityContext") == 0) {
		_dbus_dbus_service_id_bus_GetConnectionSELinuxSecurityContext (object, parameters, invocation);
	} else if (strcmp (method_name, "GetConnectionUnixProcessID") == 0) {
		_dbus_dbus_service_id_bus_GetConnectionUnixProcessID (object, parameters, invocation);
	} else if (strcmp (method_name, "GetConnectionUnixUser") == 0) {
		_dbus_dbus_service_id_bus_GetConnectionUnixUser (object, parameters, invocation);
	} else if (strcmp (method_name, "GetId") == 0) {
		_dbus_dbus_service_id_bus_GetId (object, parameters, invocation);
	} else if (strcmp (method_name, "GetNameOwner") == 0) {
		_dbus_dbus_service_id_bus_GetNameOwner (object, parameters, invocation);
	} else if (strcmp (method_name, "Hello") == 0) {
		_dbus_dbus_service_id_bus_Hello (object, parameters, invocation);
	} else if (strcmp (method_name, "ListActivatableNames") == 0) {
		_dbus_dbus_service_id_bus_ListActivatableNames (object, parameters, invocation);
	} else if (strcmp (method_name, "ListNames") == 0) {
		_dbus_dbus_service_id_bus_ListNames (object, parameters, invocation);
	} else if (strcmp (method_name, "ListQueuedOwners") == 0) {
		_dbus_dbus_service_id_bus_ListQueuedOwners (object, parameters, invocation);
	} else if (strcmp (method_name, "NameHasOwner") == 0) {
		_dbus_dbus_service_id_bus_NameHasOwner (object, parameters, invocation);
	} else if (strcmp (method_name, "ReleaseName") == 0) {
		_dbus_dbus_service_id_bus_ReleaseName (object, parameters, invocation);
	} else if (strcmp (method_name, "ReloadConfig") == 0) {
		_dbus_dbus_service_id_bus_ReloadConfig (object, parameters, invocation);
	} else if (strcmp (method_name, "RemoveMatch") == 0) {
		_dbus_dbus_service_id_bus_RemoveMatch (object, parameters, invocation);
	} else if (strcmp (method_name, "RequestName") == 0) {
		_dbus_dbus_service_id_bus_RequestName (object, parameters, invocation);
	} else if (strcmp (method_name, "StartServiceByName") == 0) {
		_dbus_dbus_service_id_bus_StartServiceByName (object, parameters, invocation);
	} else if (strcmp (method_name, "UpdateActivationEnvironment") == 0) {
		_dbus_dbus_service_id_bus_UpdateActivationEnvironment (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}


static GVariant* dbus_service_id_bus_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return NULL;
}


static gboolean dbus_service_id_bus_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return FALSE;
}


static void _dbus_dbus_service_id_bus_name_acquired (GObject* _sender, const gchar* name, gpointer* _data) {
	GDBusConnection * _connection;
	const gchar * _path;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_connection = _data[1];
	_path = _data[2];
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_connection_emit_signal (_connection, NULL, _path, "org.freedesktop.DBus", "NameAcquired", _arguments, NULL);
}


static void _dbus_dbus_service_id_bus_name_lost (GObject* _sender, const gchar* name, gpointer* _data) {
	GDBusConnection * _connection;
	const gchar * _path;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_connection = _data[1];
	_path = _data[2];
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_connection_emit_signal (_connection, NULL, _path, "org.freedesktop.DBus", "NameLost", _arguments, NULL);
}


static void _dbus_dbus_service_id_bus_name_owner_changed (GObject* _sender, const gchar* name, const gchar* oldowner, const gchar* newowner, gpointer* _data) {
	GDBusConnection * _connection;
	const gchar * _path;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_connection = _data[1];
	_path = _data[2];
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (oldowner));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (newowner));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_connection_emit_signal (_connection, NULL, _path, "org.freedesktop.DBus", "NameOwnerChanged", _arguments, NULL);
}


guint dbus_service_id_bus_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
	guint result;
	gpointer *data;
	data = g_new (gpointer, 3);
	data[0] = g_object_ref (object);
	data[1] = g_object_ref (connection);
	data[2] = g_strdup (path);
	result = g_dbus_connection_register_object (connection, path, (GDBusInterfaceInfo *) (&_dbus_service_id_bus_dbus_interface_info), &_dbus_service_id_bus_dbus_interface_vtable, data, _dbus_service_id_bus_unregister_object, error);
	if (!result) {
		return 0;
	}
	g_signal_connect (object, "name-acquired", (GCallback) _dbus_dbus_service_id_bus_name_acquired, data);
	g_signal_connect (object, "name-lost", (GCallback) _dbus_dbus_service_id_bus_name_lost, data);
	g_signal_connect (object, "name-owner-changed", (GCallback) _dbus_dbus_service_id_bus_name_owner_changed, data);
	return result;
}


static void _dbus_service_id_bus_unregister_object (gpointer user_data) {
	gpointer* data;
	data = user_data;
	g_signal_handlers_disconnect_by_func (data[0], _dbus_dbus_service_id_bus_name_acquired, data);
	g_signal_handlers_disconnect_by_func (data[0], _dbus_dbus_service_id_bus_name_lost, data);
	g_signal_handlers_disconnect_by_func (data[0], _dbus_dbus_service_id_bus_name_owner_changed, data);
	g_object_unref (data[0]);
	g_object_unref (data[1]);
	g_free (data[2]);
	g_free (data);
}


void dbus_service_id_bus_sync_AddMatch (DBusServiceIDBusSync* self, const gchar* match, GError** error) {
	g_return_if_fail (self != NULL);
	DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->AddMatch (self, match, error);
}


guint8* dbus_service_id_bus_sync_GetAdtAuditSessionData (DBusServiceIDBusSync* self, const gchar* type, int* result_length1, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->GetAdtAuditSessionData (self, type, result_length1, error);
}


guint8* dbus_service_id_bus_sync_GetConnectionSELinuxSecurityContext (DBusServiceIDBusSync* self, const gchar* type, int* result_length1, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->GetConnectionSELinuxSecurityContext (self, type, result_length1, error);
}


guint32 dbus_service_id_bus_sync_GetConnectionUnixProcessID (DBusServiceIDBusSync* self, const gchar* conn, GError** error) {
	g_return_val_if_fail (self != NULL, 0U);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->GetConnectionUnixProcessID (self, conn, error);
}


guint32 dbus_service_id_bus_sync_GetConnectionUnixUser (DBusServiceIDBusSync* self, const gchar* conn, GError** error) {
	g_return_val_if_fail (self != NULL, 0U);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->GetConnectionUnixUser (self, conn, error);
}


gchar* dbus_service_id_bus_sync_GetId (DBusServiceIDBusSync* self, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->GetId (self, error);
}


gchar* dbus_service_id_bus_sync_GetNameOwner (DBusServiceIDBusSync* self, const gchar* name, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->GetNameOwner (self, name, error);
}


gchar* dbus_service_id_bus_sync_Hello (DBusServiceIDBusSync* self, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->Hello (self, error);
}


gchar** dbus_service_id_bus_sync_ListActivatableNames (DBusServiceIDBusSync* self, int* result_length1, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->ListActivatableNames (self, result_length1, error);
}


gchar** dbus_service_id_bus_sync_ListNames (DBusServiceIDBusSync* self, int* result_length1, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->ListNames (self, result_length1, error);
}


gchar** dbus_service_id_bus_sync_ListQueuedOwners (DBusServiceIDBusSync* self, const gchar* None, int* result_length1, GError** error) {
	g_return_val_if_fail (self != NULL, NULL);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->ListQueuedOwners (self, None, result_length1, error);
}


gboolean dbus_service_id_bus_sync_NameHasOwner (DBusServiceIDBusSync* self, const gchar* name, GError** error) {
	g_return_val_if_fail (self != NULL, FALSE);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->NameHasOwner (self, name, error);
}


guint32 dbus_service_id_bus_sync_ReleaseName (DBusServiceIDBusSync* self, const gchar* name, GError** error) {
	g_return_val_if_fail (self != NULL, 0U);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->ReleaseName (self, name, error);
}


void dbus_service_id_bus_sync_ReloadConfig (DBusServiceIDBusSync* self, GError** error) {
	g_return_if_fail (self != NULL);
	DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->ReloadConfig (self, error);
}


void dbus_service_id_bus_sync_RemoveMatch (DBusServiceIDBusSync* self, const gchar* match, GError** error) {
	g_return_if_fail (self != NULL);
	DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->RemoveMatch (self, match, error);
}


guint32 dbus_service_id_bus_sync_RequestName (DBusServiceIDBusSync* self, const gchar* name, guint32 flags, GError** error) {
	g_return_val_if_fail (self != NULL, 0U);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->RequestName (self, name, flags, error);
}


guint32 dbus_service_id_bus_sync_StartServiceByName (DBusServiceIDBusSync* self, const gchar* name, guint32 flags, GError** error) {
	g_return_val_if_fail (self != NULL, 0U);
	return DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->StartServiceByName (self, name, flags, error);
}


void dbus_service_id_bus_sync_UpdateActivationEnvironment (DBusServiceIDBusSync* self, GHashTable* environment, GError** error) {
	g_return_if_fail (self != NULL);
	DBUS_SERVICE_ID_BUS_SYNC_GET_INTERFACE (self)->UpdateActivationEnvironment (self, environment, error);
}


static void dbus_service_id_bus_sync_base_init (DBusServiceIDBusSyncIface * iface) {
	static gboolean initialized = FALSE;
	if (!initialized) {
		initialized = TRUE;
		g_signal_new ("name_acquired", DBUS_SERVICE_TYPE_ID_BUS_SYNC, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
		g_signal_new ("name_lost", DBUS_SERVICE_TYPE_ID_BUS_SYNC, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
		g_signal_new ("name_owner_changed", DBUS_SERVICE_TYPE_ID_BUS_SYNC, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_user_marshal_VOID__STRING_STRING_STRING, G_TYPE_NONE, 3, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
	}
}


GType dbus_service_id_bus_sync_get_type (void) {
	static volatile gsize dbus_service_id_bus_sync_type_id__volatile = 0;
	if (g_once_init_enter (&dbus_service_id_bus_sync_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (DBusServiceIDBusSyncIface), (GBaseInitFunc) dbus_service_id_bus_sync_base_init, (GBaseFinalizeFunc) NULL, (GClassInitFunc) NULL, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
		GType dbus_service_id_bus_sync_type_id;
		dbus_service_id_bus_sync_type_id = g_type_register_static (G_TYPE_INTERFACE, "DBusServiceIDBusSync", &g_define_type_info, 0);
		g_type_interface_add_prerequisite (dbus_service_id_bus_sync_type_id, G_TYPE_OBJECT);
		g_type_set_qdata (dbus_service_id_bus_sync_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) dbus_service_id_bus_sync_proxy_get_type);
		g_type_set_qdata (dbus_service_id_bus_sync_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.freedesktop.DBus");
		g_type_set_qdata (dbus_service_id_bus_sync_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) dbus_service_id_bus_sync_register_object);
		g_once_init_leave (&dbus_service_id_bus_sync_type_id__volatile, dbus_service_id_bus_sync_type_id);
	}
	return dbus_service_id_bus_sync_type_id__volatile;
}


G_DEFINE_TYPE_EXTENDED (DBusServiceIDBusSyncProxy, dbus_service_id_bus_sync_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (DBUS_SERVICE_TYPE_ID_BUS_SYNC, dbus_service_id_bus_sync_proxy_dbus_service_id_bus_sync_interface_init) )
static void dbus_service_id_bus_sync_proxy_class_init (DBusServiceIDBusSyncProxyClass* klass) {
	G_DBUS_PROXY_CLASS (klass)->g_signal = dbus_service_id_bus_sync_proxy_g_signal;
}


static void _dbus_handle_dbus_service_id_bus_sync_name_acquired (DBusServiceIDBusSync* self, GVariant* parameters) {
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp89_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp89_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp89_, NULL);
	g_variant_unref (_tmp89_);
	g_signal_emit_by_name (self, "name-acquired", name);
	_g_free0 (name);
}


static void _dbus_handle_dbus_service_id_bus_sync_name_lost (DBusServiceIDBusSync* self, GVariant* parameters) {
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp90_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp90_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp90_, NULL);
	g_variant_unref (_tmp90_);
	g_signal_emit_by_name (self, "name-lost", name);
	_g_free0 (name);
}


static void _dbus_handle_dbus_service_id_bus_sync_name_owner_changed (DBusServiceIDBusSync* self, GVariant* parameters) {
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp91_;
	gchar* oldowner = NULL;
	GVariant* _tmp92_;
	gchar* newowner = NULL;
	GVariant* _tmp93_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp91_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp91_, NULL);
	g_variant_unref (_tmp91_);
	_tmp92_ = g_variant_iter_next_value (&_arguments_iter);
	oldowner = g_variant_dup_string (_tmp92_, NULL);
	g_variant_unref (_tmp92_);
	_tmp93_ = g_variant_iter_next_value (&_arguments_iter);
	newowner = g_variant_dup_string (_tmp93_, NULL);
	g_variant_unref (_tmp93_);
	g_signal_emit_by_name (self, "name-owner-changed", name, oldowner, newowner);
	_g_free0 (name);
	_g_free0 (oldowner);
	_g_free0 (newowner);
}


static void dbus_service_id_bus_sync_proxy_g_signal (GDBusProxy* proxy, const gchar* sender_name, const gchar* signal_name, GVariant* parameters) {
	if (strcmp (signal_name, "NameAcquired") == 0) {
		_dbus_handle_dbus_service_id_bus_sync_name_acquired ((DBusServiceIDBusSync*) proxy, parameters);
	} else if (strcmp (signal_name, "NameLost") == 0) {
		_dbus_handle_dbus_service_id_bus_sync_name_lost ((DBusServiceIDBusSync*) proxy, parameters);
	} else if (strcmp (signal_name, "NameOwnerChanged") == 0) {
		_dbus_handle_dbus_service_id_bus_sync_name_owner_changed ((DBusServiceIDBusSync*) proxy, parameters);
	}
}


static void dbus_service_id_bus_sync_proxy_init (DBusServiceIDBusSyncProxy* self) {
}


static void dbus_service_id_bus_sync_proxy_AddMatch (DBusServiceIDBusSync* self, const gchar* match, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "AddMatch");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (match));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static guint8* dbus_service_id_bus_sync_proxy_GetAdtAuditSessionData (DBusServiceIDBusSync* self, const gchar* type, int* result_length1, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint8* _result;
	int _result_length1;
	GVariant* _tmp94_;
	guint8* _tmp95_;
	int _tmp95__length;
	int _tmp95__size;
	int _tmp95__length1;
	GVariantIter _tmp96_;
	GVariant* _tmp97_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetAdtAuditSessionData");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (type));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp94_ = g_variant_iter_next_value (&_reply_iter);
	_tmp95_ = g_new (guint8, 5);
	_tmp95__length = 0;
	_tmp95__size = 4;
	_tmp95__length1 = 0;
	g_variant_iter_init (&_tmp96_, _tmp94_);
	for (; (_tmp97_ = g_variant_iter_next_value (&_tmp96_)) != NULL; _tmp95__length1++) {
		if (_tmp95__size == _tmp95__length) {
			_tmp95__size = 2 * _tmp95__size;
			_tmp95_ = g_renew (guint8, _tmp95_, _tmp95__size + 1);
		}
		_tmp95_[_tmp95__length++] = g_variant_get_byte (_tmp97_);
		g_variant_unref (_tmp97_);
	}
	_result_length1 = _tmp95__length1;
	_result = _tmp95_;
	g_variant_unref (_tmp94_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static guint8* dbus_service_id_bus_sync_proxy_GetConnectionSELinuxSecurityContext (DBusServiceIDBusSync* self, const gchar* type, int* result_length1, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint8* _result;
	int _result_length1;
	GVariant* _tmp98_;
	guint8* _tmp99_;
	int _tmp99__length;
	int _tmp99__size;
	int _tmp99__length1;
	GVariantIter _tmp100_;
	GVariant* _tmp101_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetConnectionSELinuxSecurityContext");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (type));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp98_ = g_variant_iter_next_value (&_reply_iter);
	_tmp99_ = g_new (guint8, 5);
	_tmp99__length = 0;
	_tmp99__size = 4;
	_tmp99__length1 = 0;
	g_variant_iter_init (&_tmp100_, _tmp98_);
	for (; (_tmp101_ = g_variant_iter_next_value (&_tmp100_)) != NULL; _tmp99__length1++) {
		if (_tmp99__size == _tmp99__length) {
			_tmp99__size = 2 * _tmp99__size;
			_tmp99_ = g_renew (guint8, _tmp99_, _tmp99__size + 1);
		}
		_tmp99_[_tmp99__length++] = g_variant_get_byte (_tmp101_);
		g_variant_unref (_tmp101_);
	}
	_result_length1 = _tmp99__length1;
	_result = _tmp99_;
	g_variant_unref (_tmp98_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static guint32 dbus_service_id_bus_sync_proxy_GetConnectionUnixProcessID (DBusServiceIDBusSync* self, const gchar* conn, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint32 _result;
	GVariant* _tmp102_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetConnectionUnixProcessID");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (conn));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp102_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp102_);
	g_variant_unref (_tmp102_);
	g_object_unref (_reply_message);
	return _result;
}


static guint32 dbus_service_id_bus_sync_proxy_GetConnectionUnixUser (DBusServiceIDBusSync* self, const gchar* conn, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint32 _result;
	GVariant* _tmp103_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetConnectionUnixUser");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (conn));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp103_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp103_);
	g_variant_unref (_tmp103_);
	g_object_unref (_reply_message);
	return _result;
}


static gchar* dbus_service_id_bus_sync_proxy_GetId (DBusServiceIDBusSync* self, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar* _result;
	GVariant* _tmp104_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetId");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp104_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_dup_string (_tmp104_, NULL);
	g_variant_unref (_tmp104_);
	g_object_unref (_reply_message);
	return _result;
}


static gchar* dbus_service_id_bus_sync_proxy_GetNameOwner (DBusServiceIDBusSync* self, const gchar* name, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar* _result;
	GVariant* _tmp105_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "GetNameOwner");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp105_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_dup_string (_tmp105_, NULL);
	g_variant_unref (_tmp105_);
	g_object_unref (_reply_message);
	return _result;
}


static gchar* dbus_service_id_bus_sync_proxy_Hello (DBusServiceIDBusSync* self, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar* _result;
	GVariant* _tmp106_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "Hello");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp106_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_dup_string (_tmp106_, NULL);
	g_variant_unref (_tmp106_);
	g_object_unref (_reply_message);
	return _result;
}


static gchar** dbus_service_id_bus_sync_proxy_ListActivatableNames (DBusServiceIDBusSync* self, int* result_length1, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar** _result;
	int _result_length1;
	GVariant* _tmp107_;
	gchar** _tmp108_;
	int _tmp108__length;
	int _tmp108__size;
	int _tmp108__length1;
	GVariantIter _tmp109_;
	GVariant* _tmp110_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ListActivatableNames");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp107_ = g_variant_iter_next_value (&_reply_iter);
	_tmp108_ = g_new (gchar*, 5);
	_tmp108__length = 0;
	_tmp108__size = 4;
	_tmp108__length1 = 0;
	g_variant_iter_init (&_tmp109_, _tmp107_);
	for (; (_tmp110_ = g_variant_iter_next_value (&_tmp109_)) != NULL; _tmp108__length1++) {
		if (_tmp108__size == _tmp108__length) {
			_tmp108__size = 2 * _tmp108__size;
			_tmp108_ = g_renew (gchar*, _tmp108_, _tmp108__size + 1);
		}
		_tmp108_[_tmp108__length++] = g_variant_dup_string (_tmp110_, NULL);
		g_variant_unref (_tmp110_);
	}
	_result_length1 = _tmp108__length1;
	_tmp108_[_tmp108__length] = NULL;
	_result = _tmp108_;
	g_variant_unref (_tmp107_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static gchar** dbus_service_id_bus_sync_proxy_ListNames (DBusServiceIDBusSync* self, int* result_length1, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar** _result;
	int _result_length1;
	GVariant* _tmp111_;
	gchar** _tmp112_;
	int _tmp112__length;
	int _tmp112__size;
	int _tmp112__length1;
	GVariantIter _tmp113_;
	GVariant* _tmp114_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ListNames");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp111_ = g_variant_iter_next_value (&_reply_iter);
	_tmp112_ = g_new (gchar*, 5);
	_tmp112__length = 0;
	_tmp112__size = 4;
	_tmp112__length1 = 0;
	g_variant_iter_init (&_tmp113_, _tmp111_);
	for (; (_tmp114_ = g_variant_iter_next_value (&_tmp113_)) != NULL; _tmp112__length1++) {
		if (_tmp112__size == _tmp112__length) {
			_tmp112__size = 2 * _tmp112__size;
			_tmp112_ = g_renew (gchar*, _tmp112_, _tmp112__size + 1);
		}
		_tmp112_[_tmp112__length++] = g_variant_dup_string (_tmp114_, NULL);
		g_variant_unref (_tmp114_);
	}
	_result_length1 = _tmp112__length1;
	_tmp112_[_tmp112__length] = NULL;
	_result = _tmp112_;
	g_variant_unref (_tmp111_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static gchar** dbus_service_id_bus_sync_proxy_ListQueuedOwners (DBusServiceIDBusSync* self, const gchar* None, int* result_length1, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar** _result;
	int _result_length1;
	GVariant* _tmp115_;
	gchar** _tmp116_;
	int _tmp116__length;
	int _tmp116__size;
	int _tmp116__length1;
	GVariantIter _tmp117_;
	GVariant* _tmp118_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ListQueuedOwners");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (None));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return NULL;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return NULL;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_result_length1 = 0;
	_tmp115_ = g_variant_iter_next_value (&_reply_iter);
	_tmp116_ = g_new (gchar*, 5);
	_tmp116__length = 0;
	_tmp116__size = 4;
	_tmp116__length1 = 0;
	g_variant_iter_init (&_tmp117_, _tmp115_);
	for (; (_tmp118_ = g_variant_iter_next_value (&_tmp117_)) != NULL; _tmp116__length1++) {
		if (_tmp116__size == _tmp116__length) {
			_tmp116__size = 2 * _tmp116__size;
			_tmp116_ = g_renew (gchar*, _tmp116_, _tmp116__size + 1);
		}
		_tmp116_[_tmp116__length++] = g_variant_dup_string (_tmp118_, NULL);
		g_variant_unref (_tmp118_);
	}
	_result_length1 = _tmp116__length1;
	_tmp116_[_tmp116__length] = NULL;
	_result = _tmp116_;
	g_variant_unref (_tmp115_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}


static gboolean dbus_service_id_bus_sync_proxy_NameHasOwner (DBusServiceIDBusSync* self, const gchar* name, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gboolean _result;
	GVariant* _tmp119_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "NameHasOwner");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return FALSE;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return FALSE;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp119_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_boolean (_tmp119_);
	g_variant_unref (_tmp119_);
	g_object_unref (_reply_message);
	return _result;
}


static guint32 dbus_service_id_bus_sync_proxy_ReleaseName (DBusServiceIDBusSync* self, const gchar* name, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint32 _result;
	GVariant* _tmp120_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ReleaseName");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp120_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp120_);
	g_variant_unref (_tmp120_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_sync_proxy_ReloadConfig (DBusServiceIDBusSync* self, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "ReloadConfig");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static void dbus_service_id_bus_sync_proxy_RemoveMatch (DBusServiceIDBusSync* self, const gchar* match, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "RemoveMatch");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (match));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static guint32 dbus_service_id_bus_sync_proxy_RequestName (DBusServiceIDBusSync* self, const gchar* name, guint32 flags, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint32 _result;
	GVariant* _tmp121_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "RequestName");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (flags));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp121_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp121_);
	g_variant_unref (_tmp121_);
	g_object_unref (_reply_message);
	return _result;
}


static guint32 dbus_service_id_bus_sync_proxy_StartServiceByName (DBusServiceIDBusSync* self, const gchar* name, guint32 flags, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint32 _result;
	GVariant* _tmp122_;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "StartServiceByName");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (flags));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return 0U;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return 0U;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp122_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp122_);
	g_variant_unref (_tmp122_);
	g_object_unref (_reply_message);
	return _result;
}


static void dbus_service_id_bus_sync_proxy_UpdateActivationEnvironment (DBusServiceIDBusSync* self, GHashTable* environment, GError** error) {
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GVariantBuilder _tmp123_;
	GHashTableIter _tmp124_;
	gpointer _tmp125_;
	gpointer _tmp126_;
	GDBusMessage *_reply_message;
	G_DBUS_ERROR;
	G_IO_ERROR;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.DBus", "UpdateActivationEnvironment");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_hash_table_iter_init (&_tmp124_, environment);
	g_variant_builder_init (&_tmp123_, G_VARIANT_TYPE ("a{ss}"));
	while (g_hash_table_iter_next (&_tmp124_, &_tmp125_, &_tmp126_)) {
		gchar* _key;
		gchar* _value;
		_key = (gchar*) _tmp125_;
		_value = (gchar*) _tmp126_;
		g_variant_builder_add (&_tmp123_, "{?*}", g_variant_new_string (_key), g_variant_new_string (_value));
	}
	g_variant_builder_add_value (&_arguments_builder, g_variant_builder_end (&_tmp123_));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	_reply_message = g_dbus_connection_send_message_with_reply_sync (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, g_dbus_proxy_get_default_timeout ((GDBusProxy *) self), NULL, NULL, error);
	g_object_unref (_message);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	g_object_unref (_reply_message);
}


static void dbus_service_id_bus_sync_proxy_dbus_service_id_bus_sync_interface_init (DBusServiceIDBusSyncIface* iface) {
	iface->AddMatch = dbus_service_id_bus_sync_proxy_AddMatch;
	iface->GetAdtAuditSessionData = dbus_service_id_bus_sync_proxy_GetAdtAuditSessionData;
	iface->GetConnectionSELinuxSecurityContext = dbus_service_id_bus_sync_proxy_GetConnectionSELinuxSecurityContext;
	iface->GetConnectionUnixProcessID = dbus_service_id_bus_sync_proxy_GetConnectionUnixProcessID;
	iface->GetConnectionUnixUser = dbus_service_id_bus_sync_proxy_GetConnectionUnixUser;
	iface->GetId = dbus_service_id_bus_sync_proxy_GetId;
	iface->GetNameOwner = dbus_service_id_bus_sync_proxy_GetNameOwner;
	iface->Hello = dbus_service_id_bus_sync_proxy_Hello;
	iface->ListActivatableNames = dbus_service_id_bus_sync_proxy_ListActivatableNames;
	iface->ListNames = dbus_service_id_bus_sync_proxy_ListNames;
	iface->ListQueuedOwners = dbus_service_id_bus_sync_proxy_ListQueuedOwners;
	iface->NameHasOwner = dbus_service_id_bus_sync_proxy_NameHasOwner;
	iface->ReleaseName = dbus_service_id_bus_sync_proxy_ReleaseName;
	iface->ReloadConfig = dbus_service_id_bus_sync_proxy_ReloadConfig;
	iface->RemoveMatch = dbus_service_id_bus_sync_proxy_RemoveMatch;
	iface->RequestName = dbus_service_id_bus_sync_proxy_RequestName;
	iface->StartServiceByName = dbus_service_id_bus_sync_proxy_StartServiceByName;
	iface->UpdateActivationEnvironment = dbus_service_id_bus_sync_proxy_UpdateActivationEnvironment;
}


static void _dbus_dbus_service_id_bus_sync_AddMatch (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* match = NULL;
	GVariant* _tmp127_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp127_ = g_variant_iter_next_value (&_arguments_iter);
	match = g_variant_dup_string (_tmp127_, NULL);
	g_variant_unref (_tmp127_);
	dbus_service_id_bus_sync_AddMatch (self, match, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (match);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_GetAdtAuditSessionData (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* type = NULL;
	GVariant* _tmp128_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint8* result;
	int result_length1 = 0;
	guint8* _tmp129_;
	GVariantBuilder _tmp130_;
	int _tmp131_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp128_ = g_variant_iter_next_value (&_arguments_iter);
	type = g_variant_dup_string (_tmp128_, NULL);
	g_variant_unref (_tmp128_);
	result = dbus_service_id_bus_sync_GetAdtAuditSessionData (self, type, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp129_ = result;
	g_variant_builder_init (&_tmp130_, G_VARIANT_TYPE ("ay"));
	for (_tmp131_ = 0; _tmp131_ < result_length1; _tmp131_++) {
		g_variant_builder_add_value (&_tmp130_, g_variant_new_byte (*_tmp129_));
		_tmp129_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp130_));
	result = (g_free (result), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (type);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_GetConnectionSELinuxSecurityContext (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* type = NULL;
	GVariant* _tmp132_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint8* result;
	int result_length1 = 0;
	guint8* _tmp133_;
	GVariantBuilder _tmp134_;
	int _tmp135_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp132_ = g_variant_iter_next_value (&_arguments_iter);
	type = g_variant_dup_string (_tmp132_, NULL);
	g_variant_unref (_tmp132_);
	result = dbus_service_id_bus_sync_GetConnectionSELinuxSecurityContext (self, type, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp133_ = result;
	g_variant_builder_init (&_tmp134_, G_VARIANT_TYPE ("ay"));
	for (_tmp135_ = 0; _tmp135_ < result_length1; _tmp135_++) {
		g_variant_builder_add_value (&_tmp134_, g_variant_new_byte (*_tmp133_));
		_tmp133_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp134_));
	result = (g_free (result), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (type);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_GetConnectionUnixProcessID (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* conn = NULL;
	GVariant* _tmp136_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint32 result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp136_ = g_variant_iter_next_value (&_arguments_iter);
	conn = g_variant_dup_string (_tmp136_, NULL);
	g_variant_unref (_tmp136_);
	result = dbus_service_id_bus_sync_GetConnectionUnixProcessID (self, conn, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (conn);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_GetConnectionUnixUser (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* conn = NULL;
	GVariant* _tmp137_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint32 result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp137_ = g_variant_iter_next_value (&_arguments_iter);
	conn = g_variant_dup_string (_tmp137_, NULL);
	g_variant_unref (_tmp137_);
	result = dbus_service_id_bus_sync_GetConnectionUnixUser (self, conn, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (conn);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_GetId (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar* result;
	g_variant_iter_init (&_arguments_iter, parameters);
	result = dbus_service_id_bus_sync_GetId (self, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_string (result));
	_g_free0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_GetNameOwner (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp138_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar* result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp138_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp138_, NULL);
	g_variant_unref (_tmp138_);
	result = dbus_service_id_bus_sync_GetNameOwner (self, name, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_string (result));
	_g_free0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (name);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_Hello (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar* result;
	g_variant_iter_init (&_arguments_iter, parameters);
	result = dbus_service_id_bus_sync_Hello (self, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_string (result));
	_g_free0 (result);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_ListActivatableNames (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar** result;
	int result_length1 = 0;
	gchar** _tmp139_;
	GVariantBuilder _tmp140_;
	int _tmp141_;
	g_variant_iter_init (&_arguments_iter, parameters);
	result = dbus_service_id_bus_sync_ListActivatableNames (self, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp139_ = result;
	g_variant_builder_init (&_tmp140_, G_VARIANT_TYPE ("as"));
	for (_tmp141_ = 0; _tmp141_ < result_length1; _tmp141_++) {
		g_variant_builder_add_value (&_tmp140_, g_variant_new_string (*_tmp139_));
		_tmp139_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp140_));
	result = (_vala_array_free (result, result_length1, (GDestroyNotify) g_free), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_ListNames (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar** result;
	int result_length1 = 0;
	gchar** _tmp142_;
	GVariantBuilder _tmp143_;
	int _tmp144_;
	g_variant_iter_init (&_arguments_iter, parameters);
	result = dbus_service_id_bus_sync_ListNames (self, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp142_ = result;
	g_variant_builder_init (&_tmp143_, G_VARIANT_TYPE ("as"));
	for (_tmp144_ = 0; _tmp144_ < result_length1; _tmp144_++) {
		g_variant_builder_add_value (&_tmp143_, g_variant_new_string (*_tmp142_));
		_tmp142_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp143_));
	result = (_vala_array_free (result, result_length1, (GDestroyNotify) g_free), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_ListQueuedOwners (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* None = NULL;
	GVariant* _tmp145_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar** result;
	int result_length1 = 0;
	gchar** _tmp146_;
	GVariantBuilder _tmp147_;
	int _tmp148_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp145_ = g_variant_iter_next_value (&_arguments_iter);
	None = g_variant_dup_string (_tmp145_, NULL);
	g_variant_unref (_tmp145_);
	result = dbus_service_id_bus_sync_ListQueuedOwners (self, None, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_tmp146_ = result;
	g_variant_builder_init (&_tmp147_, G_VARIANT_TYPE ("as"));
	for (_tmp148_ = 0; _tmp148_ < result_length1; _tmp148_++) {
		g_variant_builder_add_value (&_tmp147_, g_variant_new_string (*_tmp146_));
		_tmp146_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp147_));
	result = (_vala_array_free (result, result_length1, (GDestroyNotify) g_free), NULL);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (None);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_NameHasOwner (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp149_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gboolean result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp149_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp149_, NULL);
	g_variant_unref (_tmp149_);
	result = dbus_service_id_bus_sync_NameHasOwner (self, name, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_boolean (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (name);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_ReleaseName (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp150_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint32 result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp150_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp150_, NULL);
	g_variant_unref (_tmp150_);
	result = dbus_service_id_bus_sync_ReleaseName (self, name, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (name);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_ReloadConfig (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	g_variant_iter_init (&_arguments_iter, parameters);
	dbus_service_id_bus_sync_ReloadConfig (self, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_RemoveMatch (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* match = NULL;
	GVariant* _tmp151_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp151_ = g_variant_iter_next_value (&_arguments_iter);
	match = g_variant_dup_string (_tmp151_, NULL);
	g_variant_unref (_tmp151_);
	dbus_service_id_bus_sync_RemoveMatch (self, match, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (match);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_RequestName (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp152_;
	guint32 flags = 0U;
	GVariant* _tmp153_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint32 result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp152_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp152_, NULL);
	g_variant_unref (_tmp152_);
	_tmp153_ = g_variant_iter_next_value (&_arguments_iter);
	flags = g_variant_get_uint32 (_tmp153_);
	g_variant_unref (_tmp153_);
	result = dbus_service_id_bus_sync_RequestName (self, name, flags, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (name);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_StartServiceByName (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	gchar* name = NULL;
	GVariant* _tmp154_;
	guint32 flags = 0U;
	GVariant* _tmp155_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint32 result;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp154_ = g_variant_iter_next_value (&_arguments_iter);
	name = g_variant_dup_string (_tmp154_, NULL);
	g_variant_unref (_tmp154_);
	_tmp155_ = g_variant_iter_next_value (&_arguments_iter);
	flags = g_variant_get_uint32 (_tmp155_);
	g_variant_unref (_tmp155_);
	result = dbus_service_id_bus_sync_StartServiceByName (self, name, flags, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (result));
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_free0 (name);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void _dbus_dbus_service_id_bus_sync_UpdateActivationEnvironment (DBusServiceIDBusSync* self, GVariant* parameters, GDBusMethodInvocation* invocation) {
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GHashTable* environment = NULL;
	GVariant* _tmp156_;
	GHashTable* _tmp157_;
	GVariantIter _tmp158_;
	GVariant* _tmp159_;
	GVariant* _tmp160_;
	GDBusMessage* _reply_message;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp156_ = g_variant_iter_next_value (&_arguments_iter);
	_tmp157_ = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_free);
	g_variant_iter_init (&_tmp158_, _tmp156_);
	while (g_variant_iter_loop (&_tmp158_, "{?*}", &_tmp159_, &_tmp160_)) {
		g_hash_table_insert (_tmp157_, g_variant_dup_string (_tmp159_, NULL), g_variant_dup_string (_tmp160_, NULL));
	}
	environment = _tmp157_;
	g_variant_unref (_tmp156_);
	dbus_service_id_bus_sync_UpdateActivationEnvironment (self, environment, &error);
	if (error) {
		g_dbus_method_invocation_return_gerror (invocation, error);
		return;
	}
	_reply_message = g_dbus_message_new_method_reply (g_dbus_method_invocation_get_message (invocation));
	g_variant_builder_init (&_reply_builder, G_VARIANT_TYPE_TUPLE);
	_reply = g_variant_builder_end (&_reply_builder);
	g_dbus_message_set_body (_reply_message, _reply);
	_g_hash_table_unref0 (environment);
	g_dbus_connection_send_message (g_dbus_method_invocation_get_connection (invocation), _reply_message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	g_object_unref (invocation);
	g_object_unref (_reply_message);
}


static void dbus_service_id_bus_sync_dbus_interface_method_call (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* method_name, GVariant* parameters, GDBusMethodInvocation* invocation, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	if (strcmp (method_name, "AddMatch") == 0) {
		_dbus_dbus_service_id_bus_sync_AddMatch (object, parameters, invocation);
	} else if (strcmp (method_name, "GetAdtAuditSessionData") == 0) {
		_dbus_dbus_service_id_bus_sync_GetAdtAuditSessionData (object, parameters, invocation);
	} else if (strcmp (method_name, "GetConnectionSELinuxSecurityContext") == 0) {
		_dbus_dbus_service_id_bus_sync_GetConnectionSELinuxSecurityContext (object, parameters, invocation);
	} else if (strcmp (method_name, "GetConnectionUnixProcessID") == 0) {
		_dbus_dbus_service_id_bus_sync_GetConnectionUnixProcessID (object, parameters, invocation);
	} else if (strcmp (method_name, "GetConnectionUnixUser") == 0) {
		_dbus_dbus_service_id_bus_sync_GetConnectionUnixUser (object, parameters, invocation);
	} else if (strcmp (method_name, "GetId") == 0) {
		_dbus_dbus_service_id_bus_sync_GetId (object, parameters, invocation);
	} else if (strcmp (method_name, "GetNameOwner") == 0) {
		_dbus_dbus_service_id_bus_sync_GetNameOwner (object, parameters, invocation);
	} else if (strcmp (method_name, "Hello") == 0) {
		_dbus_dbus_service_id_bus_sync_Hello (object, parameters, invocation);
	} else if (strcmp (method_name, "ListActivatableNames") == 0) {
		_dbus_dbus_service_id_bus_sync_ListActivatableNames (object, parameters, invocation);
	} else if (strcmp (method_name, "ListNames") == 0) {
		_dbus_dbus_service_id_bus_sync_ListNames (object, parameters, invocation);
	} else if (strcmp (method_name, "ListQueuedOwners") == 0) {
		_dbus_dbus_service_id_bus_sync_ListQueuedOwners (object, parameters, invocation);
	} else if (strcmp (method_name, "NameHasOwner") == 0) {
		_dbus_dbus_service_id_bus_sync_NameHasOwner (object, parameters, invocation);
	} else if (strcmp (method_name, "ReleaseName") == 0) {
		_dbus_dbus_service_id_bus_sync_ReleaseName (object, parameters, invocation);
	} else if (strcmp (method_name, "ReloadConfig") == 0) {
		_dbus_dbus_service_id_bus_sync_ReloadConfig (object, parameters, invocation);
	} else if (strcmp (method_name, "RemoveMatch") == 0) {
		_dbus_dbus_service_id_bus_sync_RemoveMatch (object, parameters, invocation);
	} else if (strcmp (method_name, "RequestName") == 0) {
		_dbus_dbus_service_id_bus_sync_RequestName (object, parameters, invocation);
	} else if (strcmp (method_name, "StartServiceByName") == 0) {
		_dbus_dbus_service_id_bus_sync_StartServiceByName (object, parameters, invocation);
	} else if (strcmp (method_name, "UpdateActivationEnvironment") == 0) {
		_dbus_dbus_service_id_bus_sync_UpdateActivationEnvironment (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}


static GVariant* dbus_service_id_bus_sync_dbus_interface_get_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return NULL;
}


static gboolean dbus_service_id_bus_sync_dbus_interface_set_property (GDBusConnection* connection, const gchar* sender, const gchar* object_path, const gchar* interface_name, const gchar* property_name, GVariant* value, GError** error, gpointer user_data) {
	gpointer* data;
	gpointer object;
	data = user_data;
	object = data[0];
	return FALSE;
}


static void _dbus_dbus_service_id_bus_sync_name_acquired (GObject* _sender, const gchar* name, gpointer* _data) {
	GDBusConnection * _connection;
	const gchar * _path;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_connection = _data[1];
	_path = _data[2];
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_connection_emit_signal (_connection, NULL, _path, "org.freedesktop.DBus", "NameAcquired", _arguments, NULL);
}


static void _dbus_dbus_service_id_bus_sync_name_lost (GObject* _sender, const gchar* name, gpointer* _data) {
	GDBusConnection * _connection;
	const gchar * _path;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_connection = _data[1];
	_path = _data[2];
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_connection_emit_signal (_connection, NULL, _path, "org.freedesktop.DBus", "NameLost", _arguments, NULL);
}


static void _dbus_dbus_service_id_bus_sync_name_owner_changed (GObject* _sender, const gchar* name, const gchar* oldowner, const gchar* newowner, gpointer* _data) {
	GDBusConnection * _connection;
	const gchar * _path;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_connection = _data[1];
	_path = _data[2];
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (name));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (oldowner));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (newowner));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_connection_emit_signal (_connection, NULL, _path, "org.freedesktop.DBus", "NameOwnerChanged", _arguments, NULL);
}


guint dbus_service_id_bus_sync_register_object (gpointer object, GDBusConnection* connection, const gchar* path, GError** error) {
	guint result;
	gpointer *data;
	data = g_new (gpointer, 3);
	data[0] = g_object_ref (object);
	data[1] = g_object_ref (connection);
	data[2] = g_strdup (path);
	result = g_dbus_connection_register_object (connection, path, (GDBusInterfaceInfo *) (&_dbus_service_id_bus_sync_dbus_interface_info), &_dbus_service_id_bus_sync_dbus_interface_vtable, data, _dbus_service_id_bus_sync_unregister_object, error);
	if (!result) {
		return 0;
	}
	g_signal_connect (object, "name-acquired", (GCallback) _dbus_dbus_service_id_bus_sync_name_acquired, data);
	g_signal_connect (object, "name-lost", (GCallback) _dbus_dbus_service_id_bus_sync_name_lost, data);
	g_signal_connect (object, "name-owner-changed", (GCallback) _dbus_dbus_service_id_bus_sync_name_owner_changed, data);
	return result;
}


static void _dbus_service_id_bus_sync_unregister_object (gpointer user_data) {
	gpointer* data;
	data = user_data;
	g_signal_handlers_disconnect_by_func (data[0], _dbus_dbus_service_id_bus_sync_name_acquired, data);
	g_signal_handlers_disconnect_by_func (data[0], _dbus_dbus_service_id_bus_sync_name_lost, data);
	g_signal_handlers_disconnect_by_func (data[0], _dbus_dbus_service_id_bus_sync_name_owner_changed, data);
	g_object_unref (data[0]);
	g_object_unref (data[1]);
	g_free (data[2]);
	g_free (data);
}


gboolean fso_framework_isValidDBusName (const gchar* busname) {
	gboolean result = FALSE;
	const gchar* _tmp0_;
	gchar** _tmp1_;
	gchar** _tmp2_ = NULL;
	gchar** parts;
	gint parts_length1;
	gint _parts_size_;
	gchar** _tmp3_;
	gint _tmp3__length1;
	const gchar* _tmp4_;
	gboolean _tmp5_ = FALSE;
	const gchar* _tmp6_;
	gboolean _tmp7_ = FALSE;
	g_return_val_if_fail (busname != NULL, FALSE);
	_tmp0_ = busname;
	_tmp2_ = _tmp1_ = g_strsplit (_tmp0_, ".", 0);
	parts = _tmp2_;
	parts_length1 = _vala_array_length (_tmp1_);
	_parts_size_ = parts_length1;
	_tmp3_ = parts;
	_tmp3__length1 = parts_length1;
	if (_tmp3__length1 < 2) {
		result = FALSE;
		parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
		return result;
	}
	_tmp4_ = busname;
	_tmp5_ = g_str_has_prefix (_tmp4_, ".");
	if (_tmp5_) {
		result = FALSE;
		parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
		return result;
	}
	_tmp6_ = busname;
	_tmp7_ = g_str_has_suffix (_tmp6_, ".");
	if (_tmp7_) {
		result = FALSE;
		parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
		return result;
	}
	result = TRUE;
	parts = (_vala_array_free (parts, parts_length1, (GDestroyNotify) g_free), NULL);
	return result;
}


DBusFuncDelegateHolder* dbus_func_delegate_holder_new (FsoFrameworkDBusServiceEventFunc func, void* func_target) {
	DBusFuncDelegateHolder* self;
	FsoFrameworkDBusServiceEventFunc _tmp0_;
	void* _tmp0__target;
	self = g_slice_new0 (DBusFuncDelegateHolder);
	dbus_func_delegate_holder_instance_init (self);
	_tmp0_ = func;
	_tmp0__target = func_target;
	(self->func_target_destroy_notify == NULL) ? NULL : (self->func_target_destroy_notify (self->func_target), NULL);
	self->func = NULL;
	self->func_target = NULL;
	self->func_target_destroy_notify = NULL;
	self->func = _tmp0_;
	self->func_target = _tmp0__target;
	self->func_target_destroy_notify = NULL;
	return self;
}


static void dbus_func_delegate_holder_instance_init (DBusFuncDelegateHolder * self) {
}


void dbus_func_delegate_holder_free (DBusFuncDelegateHolder* self) {
	(self->func_target_destroy_notify == NULL) ? NULL : (self->func_target_destroy_notify (self->func_target), NULL);
	self->func = NULL;
	self->func_target = NULL;
	self->func_target_destroy_notify = NULL;
	g_slice_free (DBusFuncDelegateHolder, self);
}


FsoFrameworkDBusServiceNotifierDelegate* fso_framework_dbus_service_notifier_delegate_construct (GType object_type, GType t_type, GBoxedCopyFunc t_dup_func, GDestroyNotify t_destroy_func, gpointer t) {
	FsoFrameworkDBusServiceNotifierDelegate* self = NULL;
	gconstpointer _tmp0_;
	gpointer _tmp1_;
	self = (FsoFrameworkDBusServiceNotifierDelegate*) g_type_create_instance (object_type);
	self->priv->t_type = t_type;
	self->priv->t_dup_func = t_dup_func;
	self->priv->t_destroy_func = t_destroy_func;
	_tmp0_ = t;
	_tmp1_ = ((_tmp0_ != NULL) && (t_dup_func != NULL)) ? t_dup_func ((gpointer) _tmp0_) : ((gpointer) _tmp0_);
	_t_destroy_func0 (self->priv->t);
	self->priv->t = _tmp1_;
	_t_destroy_func0 (t);
	return self;
}


FsoFrameworkDBusServiceNotifierDelegate* fso_framework_dbus_service_notifier_delegate_new (GType t_type, GBoxedCopyFunc t_dup_func, GDestroyNotify t_destroy_func, gpointer t) {
	return fso_framework_dbus_service_notifier_delegate_construct (FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE, t_type, t_dup_func, t_destroy_func, t);
}


static void fso_framework_value_dbus_service_notifier_delegate_init (GValue* value) {
	value->data[0].v_pointer = NULL;
}


static void fso_framework_value_dbus_service_notifier_delegate_free_value (GValue* value) {
	if (value->data[0].v_pointer) {
		fso_framework_dbus_service_notifier_delegate_unref (value->data[0].v_pointer);
	}
}


static void fso_framework_value_dbus_service_notifier_delegate_copy_value (const GValue* src_value, GValue* dest_value) {
	if (src_value->data[0].v_pointer) {
		dest_value->data[0].v_pointer = fso_framework_dbus_service_notifier_delegate_ref (src_value->data[0].v_pointer);
	} else {
		dest_value->data[0].v_pointer = NULL;
	}
}


static gpointer fso_framework_value_dbus_service_notifier_delegate_peek_pointer (const GValue* value) {
	return value->data[0].v_pointer;
}


static gchar* fso_framework_value_dbus_service_notifier_delegate_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	if (collect_values[0].v_pointer) {
		FsoFrameworkDBusServiceNotifierDelegate* object;
		object = collect_values[0].v_pointer;
		if (object->parent_instance.g_class == NULL) {
			return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		} else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
			return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
		}
		value->data[0].v_pointer = fso_framework_dbus_service_notifier_delegate_ref (object);
	} else {
		value->data[0].v_pointer = NULL;
	}
	return NULL;
}


static gchar* fso_framework_value_dbus_service_notifier_delegate_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
	FsoFrameworkDBusServiceNotifierDelegate** object_p;
	object_p = collect_values[0].v_pointer;
	if (!object_p) {
		return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
	}
	if (!value->data[0].v_pointer) {
		*object_p = NULL;
	} else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
		*object_p = value->data[0].v_pointer;
	} else {
		*object_p = fso_framework_dbus_service_notifier_delegate_ref (value->data[0].v_pointer);
	}
	return NULL;
}


GParamSpec* fso_framework_param_spec_dbus_service_notifier_delegate (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
	FsoFrameworkParamSpecDBusServiceNotifierDelegate* spec;
	g_return_val_if_fail (g_type_is_a (object_type, FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE), NULL);
	spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
	G_PARAM_SPEC (spec)->value_type = object_type;
	return G_PARAM_SPEC (spec);
}


gpointer fso_framework_value_get_dbus_service_notifier_delegate (const GValue* value) {
	g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE), NULL);
	return value->data[0].v_pointer;
}


void fso_framework_value_set_dbus_service_notifier_delegate (GValue* value, gpointer v_object) {
	FsoFrameworkDBusServiceNotifierDelegate* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
		fso_framework_dbus_service_notifier_delegate_ref (value->data[0].v_pointer);
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		fso_framework_dbus_service_notifier_delegate_unref (old);
	}
}


void fso_framework_value_take_dbus_service_notifier_delegate (GValue* value, gpointer v_object) {
	FsoFrameworkDBusServiceNotifierDelegate* old;
	g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE));
	old = value->data[0].v_pointer;
	if (v_object) {
		g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER_DELEGATE));
		g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
		value->data[0].v_pointer = v_object;
	} else {
		value->data[0].v_pointer = NULL;
	}
	if (old) {
		fso_framework_dbus_service_notifier_delegate_unref (old);
	}
}


static void fso_framework_dbus_service_notifier_delegate_class_init (FsoFrameworkDBusServiceNotifierDelegateClass * klass) {
	fso_framework_dbus_service_notifier_delegate_parent_class = g_type_class_peek_parent (klass);
	FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_DELEGATE_CLASS (klass)->finalize = fso_framework_dbus_service_notifier_delegate_finalize;
	g_type_class_add_private (klass, sizeof (FsoFrameworkDBusServiceNotifierDelegatePrivate));
}


static void fso_framework_dbus_service_notifier_delegate_instance_init (FsoFrameworkDBusServiceNotifierDelegate * self) {
	self->priv = FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_DELEGATE_GET_PRIVATE (self);
	self->ref_count = 1;
}


static void fso_framework_dbus_service_notifier_delegate_finalize (FsoFrameworkDBusServiceNotifierDelegate* obj) {
	FsoFrameworkDBusServiceNotifierDelegate * self;
	self = FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_DELEGATE (obj);
	((self->priv->t == NULL) || (self->priv->t_destroy_func == NULL)) ? NULL : (self->priv->t = (self->priv->t_destroy_func (self->priv->t), NULL));
}


/**
 * @class FsoFramework.DBusServiceNotifierDelegate
 */
GType fso_framework_dbus_service_notifier_delegate_get_type (void) {
	static volatile gsize fso_framework_dbus_service_notifier_delegate_type_id__volatile = 0;
	if (g_once_init_enter (&fso_framework_dbus_service_notifier_delegate_type_id__volatile)) {
		static const GTypeValueTable g_define_type_value_table = { fso_framework_value_dbus_service_notifier_delegate_init, fso_framework_value_dbus_service_notifier_delegate_free_value, fso_framework_value_dbus_service_notifier_delegate_copy_value, fso_framework_value_dbus_service_notifier_delegate_peek_pointer, "p", fso_framework_value_dbus_service_notifier_delegate_collect_value, "p", fso_framework_value_dbus_service_notifier_delegate_lcopy_value };
		static const GTypeInfo g_define_type_info = { sizeof (FsoFrameworkDBusServiceNotifierDelegateClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) fso_framework_dbus_service_notifier_delegate_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (FsoFrameworkDBusServiceNotifierDelegate), 0, (GInstanceInitFunc) fso_framework_dbus_service_notifier_delegate_instance_init, &g_define_type_value_table };
		static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
		GType fso_framework_dbus_service_notifier_delegate_type_id;
		fso_framework_dbus_service_notifier_delegate_type_id = g_type_register_fundamental (g_type_fundamental_next (), "FsoFrameworkDBusServiceNotifierDelegate", &g_define_type_info, &g_define_type_fundamental_info, 0);
		g_once_init_leave (&fso_framework_dbus_service_notifier_delegate_type_id__volatile, fso_framework_dbus_service_notifier_delegate_type_id);
	}
	return fso_framework_dbus_service_notifier_delegate_type_id__volatile;
}


gpointer fso_framework_dbus_service_notifier_delegate_ref (gpointer instance) {
	FsoFrameworkDBusServiceNotifierDelegate* self;
	self = instance;
	g_atomic_int_inc (&self->ref_count);
	return instance;
}


void fso_framework_dbus_service_notifier_delegate_unref (gpointer instance) {
	FsoFrameworkDBusServiceNotifierDelegate* self;
	self = instance;
	if (g_atomic_int_dec_and_test (&self->ref_count)) {
		FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_DELEGATE_GET_CLASS (self)->finalize (self);
		g_type_free_instance ((GTypeInstance *) self);
	}
}


static void _g_free0_ (gpointer var) {
	var = (g_free (var), NULL);
}


static void _dbus_func_delegate_holder_free0_ (gpointer var) {
	(var == NULL) ? NULL : (var = (dbus_func_delegate_holder_free (var), NULL));
}


static void _g_list_free__dbus_func_delegate_holder_free0_ (GList* self) {
	g_list_foreach (self, (GFunc) _dbus_func_delegate_holder_free0_, NULL);
	g_list_free (self);
}


static void __g_list_free__dbus_func_delegate_holder_free0_0_ (gpointer var) {
	(var == NULL) ? NULL : (var = (_g_list_free__dbus_func_delegate_holder_free0_ (var), NULL));
}


static const gchar* string_to_string (const gchar* self) {
	const gchar* result = NULL;
	g_return_val_if_fail (self != NULL, NULL);
	result = self;
	return result;
}


static void _fso_framework_dbus_service_notifier_onNameOwnerChanged_dbus_service_id_bus_name_owner_changed (DBusServiceIDBus* _sender, const gchar* name, const gchar* oldowner, const gchar* newowner, gpointer self) {
	fso_framework_dbus_service_notifier_onNameOwnerChanged (self, _sender, name, oldowner, newowner);
}


FsoFrameworkDBusServiceNotifier* fso_framework_dbus_service_notifier_construct (GType object_type) {
	FsoFrameworkDBusServiceNotifier * self = NULL;
	GHashFunc _tmp0_;
	GEqualFunc _tmp1_;
	GHashTable* _tmp2_;
	GHashFunc _tmp3_;
	GEqualFunc _tmp4_;
	GHashTable* _tmp5_;
	DBusServiceIDBus* _tmp14_;
	GError * _inner_error_ = NULL;
	self = (FsoFrameworkDBusServiceNotifier*) fso_framework_abstract_object_construct (object_type);
	_tmp0_ = g_str_hash;
	_tmp1_ = g_str_equal;
	_tmp2_ = g_hash_table_new_full (_tmp0_, _tmp1_, _g_free0_, __g_list_free__dbus_func_delegate_holder_free0_0_);
	_g_hash_table_unref0 (self->priv->appear);
	self->priv->appear = _tmp2_;
	_tmp3_ = g_str_hash;
	_tmp4_ = g_str_equal;
	_tmp5_ = g_hash_table_new_full (_tmp3_, _tmp4_, _g_free0_, __g_list_free__dbus_func_delegate_holder_free0_0_);
	_g_hash_table_unref0 (self->priv->disappear);
	self->priv->disappear = _tmp5_;
	{
		DBusServiceIDBus* _tmp6_ = NULL;
		DBusServiceIDBus* _tmp7_;
		_tmp6_ = g_initable_new (DBUS_SERVICE_TYPE_ID_BUS_PROXY, NULL, &_inner_error_, "g-flags", 0, "g-name", DBUS_SERVICE_DBUS_SERVICE_DBUS, "g-bus-type", G_BUS_TYPE_SYSTEM, "g-object-path", DBUS_SERVICE_DBUS_PATH_DBUS, "g-interface-name", "org.freedesktop.DBus", NULL);
		_tmp7_ = (DBusServiceIDBus*) _tmp6_;
		if (_inner_error_ != NULL) {
			goto __catch0_g_error;
		}
		_g_object_unref0 (self->priv->obj);
		self->priv->obj = _tmp7_;
	}
	goto __finally0;
	__catch0_g_error:
	{
		GError* e = NULL;
		FsoFrameworkLogger* _tmp8_;
		GError* _tmp9_;
		const gchar* _tmp10_;
		const gchar* _tmp11_ = NULL;
		gchar* _tmp12_ = NULL;
		gchar* _tmp13_;
		e = _inner_error_;
		_inner_error_ = NULL;
		_tmp8_ = ((FsoFrameworkAbstractObject*) self)->logger;
		_tmp9_ = e;
		_tmp10_ = _tmp9_->message;
		_tmp11_ = string_to_string (_tmp10_);
		_tmp12_ = g_strconcat ("Could not get handle on DBus object at system bus: ", _tmp11_, NULL);
		_tmp13_ = _tmp12_;
		fso_framework_logger_critical (_tmp8_, _tmp13_);
		_g_free0 (_tmp13_);
		_g_error_free0 (e);
	}
	__finally0:
	if (_inner_error_ != NULL) {
		g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code);
		g_clear_error (&_inner_error_);
		return NULL;
	}
	_tmp14_ = self->priv->obj;
	g_signal_connect_object (_tmp14_, "name-owner-changed", (GCallback) _fso_framework_dbus_service_notifier_onNameOwnerChanged_dbus_service_id_bus_name_owner_changed, self, 0);
	return self;
}


FsoFrameworkDBusServiceNotifier* fso_framework_dbus_service_notifier_new (void) {
	return fso_framework_dbus_service_notifier_construct (FSO_FRAMEWORK_TYPE_DBUS_SERVICE_NOTIFIER);
}


static gchar* fso_framework_dbus_service_notifier_real_repr (FsoFrameworkAbstractObject* base) {
	FsoFrameworkDBusServiceNotifier * self;
	gchar* result = NULL;
	gchar* _tmp0_;
	self = (FsoFrameworkDBusServiceNotifier*) base;
	_tmp0_ = g_strdup ("");
	result = _tmp0_;
	return result;
}


static void fso_framework_dbus_service_notifier_onNameOwnerChanged (FsoFrameworkDBusServiceNotifier* self, GObject* obj, const gchar* name, const gchar* oldowner, const gchar* newowner) {
	GList* list = NULL;
	gboolean _tmp0_ = FALSE;
	const gchar* _tmp1_;
	gboolean _tmp3_;
	GList* _tmp14_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (obj != NULL);
	g_return_if_fail (name != NULL);
	g_return_if_fail (oldowner != NULL);
	g_return_if_fail (newowner != NULL);
	_tmp1_ = oldowner;
	if (g_strcmp0 (_tmp1_, "") == 0) {
		const gchar* _tmp2_;
		_tmp2_ = newowner;
		_tmp0_ = g_strcmp0 (_tmp2_, "") != 0;
	} else {
		_tmp0_ = FALSE;
	}
	_tmp3_ = _tmp0_;
	if (_tmp3_) {
		GHashTable* _tmp4_;
		const gchar* _tmp5_;
		gconstpointer _tmp6_ = NULL;
		_tmp4_ = self->priv->appear;
		_tmp5_ = name;
		_tmp6_ = g_hash_table_lookup (_tmp4_, _tmp5_);
		list = (GList*) _tmp6_;
	} else {
		gboolean _tmp7_ = FALSE;
		const gchar* _tmp8_;
		gboolean _tmp10_;
		_tmp8_ = oldowner;
		if (g_strcmp0 (_tmp8_, "") != 0) {
			const gchar* _tmp9_;
			_tmp9_ = newowner;
			_tmp7_ = g_strcmp0 (_tmp9_, "") == 0;
		} else {
			_tmp7_ = FALSE;
		}
		_tmp10_ = _tmp7_;
		if (_tmp10_) {
			GHashTable* _tmp11_;
			const gchar* _tmp12_;
			gconstpointer _tmp13_ = NULL;
			_tmp11_ = self->priv->disappear;
			_tmp12_ = name;
			_tmp13_ = g_hash_table_lookup (_tmp11_, _tmp12_);
			list = (GList*) _tmp13_;
		} else {
			return;
		}
	}
	_tmp14_ = list;
	if (_tmp14_ != NULL) {
		GList* _tmp15_;
		_tmp15_ = list;
		{
			GList* el_collection = NULL;
			GList* el_it = NULL;
			el_collection = _tmp15_;
			for (el_it = el_collection; el_it != NULL; el_it = el_it->next) {
				DBusFuncDelegateHolder* el = NULL;
				el = (DBusFuncDelegateHolder*) el_it->data;
				{
					DBusFuncDelegateHolder* _tmp16_;
					FsoFrameworkDBusServiceEventFunc _tmp17_;
					void* _tmp17__target;
					const gchar* _tmp18_;
					_tmp16_ = el;
					_tmp17_ = _tmp16_->func;
					_tmp17__target = _tmp16_->func_target;
					_tmp18_ = name;
					_tmp17_ (_tmp18_, _tmp17__target);
				}
			}
		}
	}
}


void fso_framework_dbus_service_notifier_notifyAppearing (FsoFrameworkDBusServiceNotifier* self, const gchar* busname, FsoFrameworkDBusServiceEventFunc callback, void* callback_target) {
	GHashTable* _tmp0_;
	const gchar* _tmp1_;
	gconstpointer _tmp2_ = NULL;
	GList* list;
	GList* _tmp3_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (busname != NULL);
	_tmp0_ = self->priv->appear;
	_tmp1_ = busname;
	_tmp2_ = g_hash_table_lookup (_tmp0_, _tmp1_);
	list = (GList*) _tmp2_;
	_tmp3_ = list;
	if (_tmp3_ == NULL) {
		GList* newlist;
		FsoFrameworkDBusServiceEventFunc _tmp4_;
		void* _tmp4__target;
		DBusFuncDelegateHolder* _tmp5_;
		GHashTable* _tmp6_;
		const gchar* _tmp7_;
		gchar* _tmp8_;
		GList* _tmp9_;
		newlist = NULL;
		_tmp4_ = callback;
		_tmp4__target = callback_target;
		_tmp5_ = dbus_func_delegate_holder_new (_tmp4_, _tmp4__target);
		newlist = g_list_append (newlist, _tmp5_);
		_tmp6_ = self->priv->appear;
		_tmp7_ = busname;
		_tmp8_ = g_strdup (_tmp7_);
		_tmp9_ = newlist;
		newlist = NULL;
		g_hash_table_insert (_tmp6_, _tmp8_, _tmp9_);
		__g_list_free__dbus_func_delegate_holder_free0_0 (newlist);
	} else {
		FsoFrameworkDBusServiceEventFunc _tmp10_;
		void* _tmp10__target;
		DBusFuncDelegateHolder* _tmp11_;
		_tmp10_ = callback;
		_tmp10__target = callback_target;
		_tmp11_ = dbus_func_delegate_holder_new (_tmp10_, _tmp10__target);
		list = g_list_append (list, _tmp11_);
	}
}


void fso_framework_dbus_service_notifier_notifyDisappearing (FsoFrameworkDBusServiceNotifier* self, const gchar* busname, FsoFrameworkDBusServiceEventFunc callback, void* callback_target) {
	GHashTable* _tmp0_;
	const gchar* _tmp1_;
	gconstpointer _tmp2_ = NULL;
	GList* list;
	GList* _tmp3_;
	g_return_if_fail (self != NULL);
	g_return_if_fail (busname != NULL);
	_tmp0_ = self->priv->disappear;
	_tmp1_ = busname;
	_tmp2_ = g_hash_table_lookup (_tmp0_, _tmp1_);
	list = (GList*) _tmp2_;
	_tmp3_ = list;
	if (_tmp3_ == NULL) {
		GList* newlist;
		FsoFrameworkDBusServiceEventFunc _tmp4_;
		void* _tmp4__target;
		DBusFuncDelegateHolder* _tmp5_;
		GHashTable* _tmp6_;
		const gchar* _tmp7_;
		gchar* _tmp8_;
		GList* _tmp9_;
		newlist = NULL;
		_tmp4_ = callback;
		_tmp4__target = callback_target;
		_tmp5_ = dbus_func_delegate_holder_new (_tmp4_, _tmp4__target);
		newlist = g_list_append (newlist, _tmp5_);
		_tmp6_ = self->priv->disappear;
		_tmp7_ = busname;
		_tmp8_ = g_strdup (_tmp7_);
		_tmp9_ = newlist;
		newlist = NULL;
		g_hash_table_insert (_tmp6_, _tmp8_, _tmp9_);
		__g_list_free__dbus_func_delegate_holder_free0_0 (newlist);
	} else {
		FsoFrameworkDBusServiceEventFunc _tmp10_;
		void* _tmp10__target;
		DBusFuncDelegateHolder* _tmp11_;
		_tmp10_ = callback;
		_tmp10__target = callback_target;
		_tmp11_ = dbus_func_delegate_holder_new (_tmp10_, _tmp10__target);
		list = g_list_append (list, _tmp11_);
	}
}


static void fso_framework_dbus_service_notifier_class_init (FsoFrameworkDBusServiceNotifierClass * klass) {
	fso_framework_dbus_service_notifier_parent_class = g_type_class_peek_parent (klass);
	g_type_class_add_private (klass, sizeof (FsoFrameworkDBusServiceNotifierPrivate));
	FSO_FRAMEWORK_ABSTRACT_OBJECT_CLASS (klass)->repr = fso_framework_dbus_service_notifier_real_repr;
	G_OBJECT_CLASS (klass)->finalize = fso_framework_dbus_service_notifier_finalize;
}


static void fso_framework_dbus_service_notifier_instance_init (FsoFrameworkDBusServiceNotifier * self) {
	self->priv = FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER_GET_PRIVATE (self);
}


static void fso_framework_dbus_service_notifier_finalize (GObject* obj) {
	FsoFrameworkDBusServiceNotifier * self;
	self = FSO_FRAMEWORK_DBUS_SERVICE_NOTIFIER (obj);
	_g_object_unref0 (self->priv->obj);
	_g_hash_table_unref0 (self->priv->appear);
	_g_hash_table_unref0 (self->priv->disappear);
	G_OBJECT_CLASS (fso_framework_dbus_service_notifier_parent_class)->finalize (obj);
}


/**
 * @class FsoFramework.DBusServiceNotifier
 *
 **/
GType fso_framework_dbus_service_notifier_get_type (void) {
	static volatile gsize fso_framework_dbus_service_notifier_type_id__volatile = 0;
	if (g_once_init_enter (&fso_framework_dbus_service_notifier_type_id__volatile)) {
		static const GTypeInfo g_define_type_info = { sizeof (FsoFrameworkDBusServiceNotifierClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) fso_framework_dbus_service_notifier_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (FsoFrameworkDBusServiceNotifier), 0, (GInstanceInitFunc) fso_framework_dbus_service_notifier_instance_init, NULL };
		GType fso_framework_dbus_service_notifier_type_id;
		fso_framework_dbus_service_notifier_type_id = g_type_register_static (FSO_FRAMEWORK_TYPE_ABSTRACT_OBJECT, "FsoFrameworkDBusServiceNotifier", &g_define_type_info, 0);
		g_once_init_leave (&fso_framework_dbus_service_notifier_type_id__volatile, fso_framework_dbus_service_notifier_type_id);
	}
	return fso_framework_dbus_service_notifier_type_id__volatile;
}


static void _vala_array_destroy (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	if ((array != NULL) && (destroy_func != NULL)) {
		int i;
		for (i = 0; i < array_length; i = i + 1) {
			if (((gpointer*) array)[i] != NULL) {
				destroy_func (((gpointer*) array)[i]);
			}
		}
	}
}


static void _vala_array_free (gpointer array, gint array_length, GDestroyNotify destroy_func) {
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}


static gint _vala_array_length (gpointer array) {
	int length;
	length = 0;
	if (array) {
		while (((gpointer*) array)[length]) {
			length++;
		}
	}
	return length;
}



