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

/* remote.vala
 *
 * Copyright © 2011-2012 Collabora Ltd.
 *             By Siegfried-Angel Gevatter Pujals <siegfried@gevatter.com>
 * Copyright © 2011 Michal Hruby <michal.mhr@gmail.com>
 *
 * This program 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 program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#include "zeitgeist.h"
#include <glib.h>
#include <string.h>
#include <gio/gio.h>
#include <stdlib.h>
#include <float.h>
#include <math.h>

#if !defined(VALA_STRICT_C)
#if !defined(__clang__) && defined(__GNUC__) && (__GNUC__ >= 14)
#pragma GCC diagnostic warning "-Wincompatible-pointer-types"
#elif defined(__clang__) && (__clang_major__ >= 16)
#pragma clang diagnostic ignored "-Wincompatible-function-pointer-types"
#pragma clang diagnostic ignored "-Wincompatible-pointer-types"
#endif
#endif

typedef GDBusProxy ZeitgeistRemoteLogProxy;
typedef GDBusProxyClass ZeitgeistRemoteLogProxyClass;
typedef struct _ZeitgeistRemoteLogDeleteEventsReadyData ZeitgeistRemoteLogDeleteEventsReadyData;
#define _g_variant_unref0(var) ((var == NULL) ? NULL : (var = (g_variant_unref (var), NULL)))
typedef struct _ZeitgeistRemoteLogFindEventIdsReadyData ZeitgeistRemoteLogFindEventIdsReadyData;
typedef struct _ZeitgeistRemoteLogFindEventsReadyData ZeitgeistRemoteLogFindEventsReadyData;
typedef struct _ZeitgeistRemoteLogFindRelatedUrisReadyData ZeitgeistRemoteLogFindRelatedUrisReadyData;
typedef struct _ZeitgeistRemoteLogGetEventsReadyData ZeitgeistRemoteLogGetEventsReadyData;
typedef struct _ZeitgeistRemoteLogInsertEventsReadyData ZeitgeistRemoteLogInsertEventsReadyData;
typedef struct _ZeitgeistRemoteLogInstallMonitorReadyData ZeitgeistRemoteLogInstallMonitorReadyData;
#define _g_free0(var) (var = (g_free (var), NULL))
typedef struct _ZeitgeistRemoteLogRemoveMonitorReadyData ZeitgeistRemoteLogRemoveMonitorReadyData;
typedef struct _ZeitgeistRemoteLogQuitReadyData ZeitgeistRemoteLogQuitReadyData;
typedef GDBusProxy ZeitgeistRemoteMonitorProxy;
typedef GDBusProxyClass ZeitgeistRemoteMonitorProxyClass;
typedef struct _ZeitgeistRemoteMonitorNotifyInsertReadyData ZeitgeistRemoteMonitorNotifyInsertReadyData;
typedef struct _ZeitgeistRemoteMonitorNotifyDeleteReadyData ZeitgeistRemoteMonitorNotifyDeleteReadyData;
typedef GDBusProxy ZeitgeistRemoteSimpleIndexerProxy;
typedef GDBusProxyClass ZeitgeistRemoteSimpleIndexerProxyClass;
typedef struct _ZeitgeistRemoteSimpleIndexerSearchReadyData ZeitgeistRemoteSimpleIndexerSearchReadyData;
typedef struct _ZeitgeistRemoteSimpleIndexerSearchWithRelevanciesReadyData ZeitgeistRemoteSimpleIndexerSearchWithRelevanciesReadyData;
enum  {
	ZEITGEIST_NETWORK_MANAGER_DBUS_STATE_CHANGED_SIGNAL,
	ZEITGEIST_NETWORK_MANAGER_DBUS_NUM_SIGNALS
};
static guint zeitgeist_network_manager_dbus_signals[ZEITGEIST_NETWORK_MANAGER_DBUS_NUM_SIGNALS] = {0};
typedef GDBusProxy ZeitgeistNetworkManagerDBusProxy;
typedef GDBusProxyClass ZeitgeistNetworkManagerDBusProxyClass;
enum  {
	ZEITGEIST_CONNMAN_MANAGER_DBUS_STATE_CHANGED_SIGNAL,
	ZEITGEIST_CONNMAN_MANAGER_DBUS_NUM_SIGNALS
};
static guint zeitgeist_connman_manager_dbus_signals[ZEITGEIST_CONNMAN_MANAGER_DBUS_NUM_SIGNALS] = {0};
typedef GDBusProxy ZeitgeistConnmanManagerDBusProxy;
typedef GDBusProxyClass ZeitgeistConnmanManagerDBusProxyClass;

struct _ZeitgeistRemoteLogDeleteEventsReadyData {
	GDBusMethodInvocation* _invocation_;
	guint32* event_ids;
	gint event_ids_length1;
};

struct _ZeitgeistRemoteLogFindEventIdsReadyData {
	GDBusMethodInvocation* _invocation_;
	GVariant* time_range;
	GVariant* event_templates;
	guint storage_state;
	guint num_events;
	guint result_type;
};

struct _ZeitgeistRemoteLogFindEventsReadyData {
	GDBusMethodInvocation* _invocation_;
	GVariant* time_range;
	GVariant* event_templates;
	guint storage_state;
	guint num_events;
	guint result_type;
};

struct _ZeitgeistRemoteLogFindRelatedUrisReadyData {
	GDBusMethodInvocation* _invocation_;
	GVariant* time_range;
	GVariant* event_templates;
	GVariant* result_event_templates;
	guint storage_state;
	guint num_events;
	guint result_type;
};

struct _ZeitgeistRemoteLogGetEventsReadyData {
	GDBusMethodInvocation* _invocation_;
	guint32* event_ids;
	gint event_ids_length1;
};

struct _ZeitgeistRemoteLogInsertEventsReadyData {
	GDBusMethodInvocation* _invocation_;
	GVariant* events;
};

struct _ZeitgeistRemoteLogInstallMonitorReadyData {
	GDBusMethodInvocation* _invocation_;
	char* monitor_path;
	GVariant* time_range;
	GVariant* event_templates;
};

struct _ZeitgeistRemoteLogRemoveMonitorReadyData {
	GDBusMethodInvocation* _invocation_;
	char* monitor_path;
};

struct _ZeitgeistRemoteLogQuitReadyData {
	GDBusMethodInvocation* _invocation_;
};

struct _ZeitgeistRemoteMonitorNotifyInsertReadyData {
	GDBusMethodInvocation* _invocation_;
	GVariant* time_range;
	GVariant* events;
};

struct _ZeitgeistRemoteMonitorNotifyDeleteReadyData {
	GDBusMethodInvocation* _invocation_;
	GVariant* time_range;
	guint32* event_ids;
	gint event_ids_length1;
};

struct _ZeitgeistRemoteSimpleIndexerSearchReadyData {
	GDBusMethodInvocation* _invocation_;
	gchar* query_string;
	GVariant* time_range;
	GVariant* filter_templates;
	guint offset;
	guint count;
	guint result_type;
};

struct _ZeitgeistRemoteSimpleIndexerSearchWithRelevanciesReadyData {
	GDBusMethodInvocation* _invocation_;
	gchar* query_string;
	GVariant* time_range;
	GVariant* filter_templates;
	guint storage_state;
	guint offset;
	guint count;
	guint result_type;
};

static GType zeitgeist_remote_log_get_type_once (void);
static void zeitgeist_remote_log_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 zeitgeist_remote_log_proxy_delete_events_async (ZeitgeistRemoteLog* self,
                                                     guint32* event_ids,
                                                     gint event_ids_length1,
                                                     GCancellable* cancellable,
                                                     const char* sender,
                                                     GAsyncReadyCallback _callback_,
                                                     gpointer _user_data_);
static GVariant* zeitgeist_remote_log_proxy_delete_events_finish (ZeitgeistRemoteLog* self,
                                                           GAsyncResult* _res_,
                                                           GError** error);
static void zeitgeist_remote_log_proxy_find_event_ids_async (ZeitgeistRemoteLog* self,
                                                      GVariant* time_range,
                                                      GVariant* event_templates,
                                                      guint storage_state,
                                                      guint num_events,
                                                      guint result_type,
                                                      GCancellable* cancellable,
                                                      const char* sender,
                                                      GAsyncReadyCallback _callback_,
                                                      gpointer _user_data_);
static guint32* zeitgeist_remote_log_proxy_find_event_ids_finish (ZeitgeistRemoteLog* self,
                                                           GAsyncResult* _res_,
                                                           gint* result_length1,
                                                           GError** error);
static void zeitgeist_remote_log_proxy_find_events_async (ZeitgeistRemoteLog* self,
                                                   GVariant* time_range,
                                                   GVariant* event_templates,
                                                   guint storage_state,
                                                   guint num_events,
                                                   guint result_type,
                                                   GCancellable* cancellable,
                                                   const char* sender,
                                                   GAsyncReadyCallback _callback_,
                                                   gpointer _user_data_);
static GVariant* zeitgeist_remote_log_proxy_find_events_finish (ZeitgeistRemoteLog* self,
                                                         GAsyncResult* _res_,
                                                         GError** error);
static void zeitgeist_remote_log_proxy_find_related_uris_async (ZeitgeistRemoteLog* self,
                                                         GVariant* time_range,
                                                         GVariant* event_templates,
                                                         GVariant* result_event_templates,
                                                         guint storage_state,
                                                         guint num_events,
                                                         guint result_type,
                                                         GCancellable* cancellable,
                                                         const char* sender,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
static gchar** zeitgeist_remote_log_proxy_find_related_uris_finish (ZeitgeistRemoteLog* self,
                                                             GAsyncResult* _res_,
                                                             gint* result_length1,
                                                             GError** error);
static void zeitgeist_remote_log_proxy_get_events_async (ZeitgeistRemoteLog* self,
                                                  guint32* event_ids,
                                                  gint event_ids_length1,
                                                  GCancellable* cancellable,
                                                  const char* sender,
                                                  GAsyncReadyCallback _callback_,
                                                  gpointer _user_data_);
static GVariant* zeitgeist_remote_log_proxy_get_events_finish (ZeitgeistRemoteLog* self,
                                                        GAsyncResult* _res_,
                                                        GError** error);
static void zeitgeist_remote_log_proxy_insert_events_async (ZeitgeistRemoteLog* self,
                                                     GVariant* events,
                                                     GCancellable* cancellable,
                                                     const char* sender,
                                                     GAsyncReadyCallback _callback_,
                                                     gpointer _user_data_);
static guint32* zeitgeist_remote_log_proxy_insert_events_finish (ZeitgeistRemoteLog* self,
                                                          GAsyncResult* _res_,
                                                          gint* result_length1,
                                                          GError** error);
static void zeitgeist_remote_log_proxy_install_monitor_async (ZeitgeistRemoteLog* self,
                                                       const char* monitor_path,
                                                       GVariant* time_range,
                                                       GVariant* event_templates,
                                                       const char* owner,
                                                       GAsyncReadyCallback _callback_,
                                                       gpointer _user_data_);
static void zeitgeist_remote_log_proxy_install_monitor_finish (ZeitgeistRemoteLog* self,
                                                        GAsyncResult* _res_,
                                                        GError** error);
static void zeitgeist_remote_log_proxy_remove_monitor_async (ZeitgeistRemoteLog* self,
                                                      const char* monitor_path,
                                                      const char* owner,
                                                      GAsyncReadyCallback _callback_,
                                                      gpointer _user_data_);
static void zeitgeist_remote_log_proxy_remove_monitor_finish (ZeitgeistRemoteLog* self,
                                                       GAsyncResult* _res_,
                                                       GError** error);
static void zeitgeist_remote_log_proxy_quit_async (ZeitgeistRemoteLog* self,
                                            GCancellable* cancellable,
                                            GAsyncReadyCallback _callback_,
                                            gpointer _user_data_);
static void zeitgeist_remote_log_proxy_quit_finish (ZeitgeistRemoteLog* self,
                                             GAsyncResult* _res_,
                                             GError** error);
static gchar** zeitgeist_remote_log_dbus_proxy_get_extensions (ZeitgeistRemoteLog* self,
                                                        gint* result_length1);
static void zeitgeist_remote_log_dbus_proxy_get_version (ZeitgeistRemoteLog* self,
                                                  ZeitgeistVersionStruct* result);
static gchar* zeitgeist_remote_log_dbus_proxy_get_datapath (ZeitgeistRemoteLog* self);
static void zeitgeist_remote_log_proxy_zeitgeist_remote_log_interface_init (ZeitgeistRemoteLogIface* iface);
static void _dbus_zeitgeist_remote_log_delete_events (ZeitgeistRemoteLog* self,
                                               GVariant* _parameters_,
                                               GDBusMethodInvocation* invocation);
static void _dbus_zeitgeist_remote_log_delete_events_ready (GObject * source_object,
                                                     GAsyncResult * _res_,
                                                     gpointer _user_data_);
static void _dbus_zeitgeist_remote_log_find_event_ids (ZeitgeistRemoteLog* self,
                                                GVariant* _parameters_,
                                                GDBusMethodInvocation* invocation);
static void _dbus_zeitgeist_remote_log_find_event_ids_ready (GObject * source_object,
                                                      GAsyncResult * _res_,
                                                      gpointer _user_data_);
static void _dbus_zeitgeist_remote_log_find_events (ZeitgeistRemoteLog* self,
                                             GVariant* _parameters_,
                                             GDBusMethodInvocation* invocation);
static void _dbus_zeitgeist_remote_log_find_events_ready (GObject * source_object,
                                                   GAsyncResult * _res_,
                                                   gpointer _user_data_);
static void _dbus_zeitgeist_remote_log_find_related_uris (ZeitgeistRemoteLog* self,
                                                   GVariant* _parameters_,
                                                   GDBusMethodInvocation* invocation);
static void _dbus_zeitgeist_remote_log_find_related_uris_ready (GObject * source_object,
                                                         GAsyncResult * _res_,
                                                         gpointer _user_data_);
static void _dbus_zeitgeist_remote_log_get_events (ZeitgeistRemoteLog* self,
                                            GVariant* _parameters_,
                                            GDBusMethodInvocation* invocation);
static void _dbus_zeitgeist_remote_log_get_events_ready (GObject * source_object,
                                                  GAsyncResult * _res_,
                                                  gpointer _user_data_);
static void _dbus_zeitgeist_remote_log_insert_events (ZeitgeistRemoteLog* self,
                                               GVariant* _parameters_,
                                               GDBusMethodInvocation* invocation);
static void _dbus_zeitgeist_remote_log_insert_events_ready (GObject * source_object,
                                                     GAsyncResult * _res_,
                                                     gpointer _user_data_);
static void _dbus_zeitgeist_remote_log_install_monitor (ZeitgeistRemoteLog* self,
                                                 GVariant* _parameters_,
                                                 GDBusMethodInvocation* invocation);
static void _dbus_zeitgeist_remote_log_install_monitor_ready (GObject * source_object,
                                                       GAsyncResult * _res_,
                                                       gpointer _user_data_);
static void _dbus_zeitgeist_remote_log_remove_monitor (ZeitgeistRemoteLog* self,
                                                GVariant* _parameters_,
                                                GDBusMethodInvocation* invocation);
static void _dbus_zeitgeist_remote_log_remove_monitor_ready (GObject * source_object,
                                                      GAsyncResult * _res_,
                                                      gpointer _user_data_);
static void _dbus_zeitgeist_remote_log_quit (ZeitgeistRemoteLog* self,
                                      GVariant* _parameters_,
                                      GDBusMethodInvocation* invocation);
static void _dbus_zeitgeist_remote_log_quit_ready (GObject * source_object,
                                            GAsyncResult * _res_,
                                            gpointer _user_data_);
static void zeitgeist_remote_log_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* zeitgeist_remote_log_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 GVariant* _dbus_zeitgeist_remote_log_get_extensions (ZeitgeistRemoteLog* self);
static GVariant* _dbus_zeitgeist_remote_log_get_version (ZeitgeistRemoteLog* self);
static GVariant* _dbus_zeitgeist_remote_log_get_datapath (ZeitgeistRemoteLog* self);
static gboolean zeitgeist_remote_log_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 _zeitgeist_remote_log_unregister_object (gpointer user_data);
static GType zeitgeist_remote_monitor_get_type_once (void);
static void zeitgeist_remote_monitor_proxy_g_signal (GDBusProxy* proxy,
                                              const gchar* sender_name,
                                              const gchar* signal_name,
                                              GVariant* parameters);
static void zeitgeist_remote_monitor_proxy_notify_insert_async (ZeitgeistRemoteMonitor* self,
                                                         GVariant* time_range,
                                                         GVariant* events,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
static void zeitgeist_remote_monitor_proxy_notify_insert_finish (ZeitgeistRemoteMonitor* self,
                                                          GAsyncResult* _res_,
                                                          GError** error);
static void zeitgeist_remote_monitor_proxy_notify_delete_async (ZeitgeistRemoteMonitor* self,
                                                         GVariant* time_range,
                                                         guint32* event_ids,
                                                         gint event_ids_length1,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
static void zeitgeist_remote_monitor_proxy_notify_delete_finish (ZeitgeistRemoteMonitor* self,
                                                          GAsyncResult* _res_,
                                                          GError** error);
static void zeitgeist_remote_monitor_proxy_zeitgeist_remote_monitor_interface_init (ZeitgeistRemoteMonitorIface* iface);
static void _dbus_zeitgeist_remote_monitor_notify_insert (ZeitgeistRemoteMonitor* self,
                                                   GVariant* _parameters_,
                                                   GDBusMethodInvocation* invocation);
static void _dbus_zeitgeist_remote_monitor_notify_insert_ready (GObject * source_object,
                                                         GAsyncResult * _res_,
                                                         gpointer _user_data_);
static void _dbus_zeitgeist_remote_monitor_notify_delete (ZeitgeistRemoteMonitor* self,
                                                   GVariant* _parameters_,
                                                   GDBusMethodInvocation* invocation);
static void _dbus_zeitgeist_remote_monitor_notify_delete_ready (GObject * source_object,
                                                         GAsyncResult * _res_,
                                                         gpointer _user_data_);
static void zeitgeist_remote_monitor_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* zeitgeist_remote_monitor_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 zeitgeist_remote_monitor_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 _zeitgeist_remote_monitor_unregister_object (gpointer user_data);
static GType zeitgeist_remote_simple_indexer_get_type_once (void);
static void zeitgeist_remote_simple_indexer_proxy_g_signal (GDBusProxy* proxy,
                                                     const gchar* sender_name,
                                                     const gchar* signal_name,
                                                     GVariant* parameters);
static void zeitgeist_remote_simple_indexer_proxy_search_async (ZeitgeistRemoteSimpleIndexer* self,
                                                         const gchar* query_string,
                                                         GVariant* time_range,
                                                         GVariant* filter_templates,
                                                         guint offset,
                                                         guint count,
                                                         guint result_type,
                                                         GCancellable* cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_);
static void zeitgeist_remote_simple_indexer_proxy_search_finish (ZeitgeistRemoteSimpleIndexer* self,
                                                          GAsyncResult* _res_,
                                                          GVariant** events,
                                                          guint* matches,
                                                          GError** error);
static void zeitgeist_remote_simple_indexer_proxy_search_with_relevancies_async (ZeitgeistRemoteSimpleIndexer* self,
                                                                          const gchar* query_string,
                                                                          GVariant* time_range,
                                                                          GVariant* filter_templates,
                                                                          guint storage_state,
                                                                          guint offset,
                                                                          guint count,
                                                                          guint result_type,
                                                                          GCancellable* cancellable,
                                                                          GAsyncReadyCallback _callback_,
                                                                          gpointer _user_data_);
static void zeitgeist_remote_simple_indexer_proxy_search_with_relevancies_finish (ZeitgeistRemoteSimpleIndexer* self,
                                                                           GAsyncResult* _res_,
                                                                           GVariant** events,
                                                                           gdouble** relevancies,
                                                                           gint* relevancies_length1,
                                                                           guint* matches,
                                                                           GError** error);
static void zeitgeist_remote_simple_indexer_proxy_zeitgeist_remote_simple_indexer_interface_init (ZeitgeistRemoteSimpleIndexerIface* iface);
static void _dbus_zeitgeist_remote_simple_indexer_search (ZeitgeistRemoteSimpleIndexer* self,
                                                   GVariant* _parameters_,
                                                   GDBusMethodInvocation* invocation);
static void _dbus_zeitgeist_remote_simple_indexer_search_ready (GObject * source_object,
                                                         GAsyncResult * _res_,
                                                         gpointer _user_data_);
static void _dbus_zeitgeist_remote_simple_indexer_search_with_relevancies (ZeitgeistRemoteSimpleIndexer* self,
                                                                    GVariant* _parameters_,
                                                                    GDBusMethodInvocation* invocation);
static void _dbus_zeitgeist_remote_simple_indexer_search_with_relevancies_ready (GObject * source_object,
                                                                          GAsyncResult * _res_,
                                                                          gpointer _user_data_);
static void zeitgeist_remote_simple_indexer_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* zeitgeist_remote_simple_indexer_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 zeitgeist_remote_simple_indexer_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 _zeitgeist_remote_simple_indexer_unregister_object (gpointer user_data);
static GType zeitgeist_network_manager_dbus_get_type_once (void);
static void zeitgeist_network_manager_dbus_proxy_g_signal (GDBusProxy* proxy,
                                                    const gchar* sender_name,
                                                    const gchar* signal_name,
                                                    GVariant* parameters);
static void _dbus_handle_zeitgeist_network_manager_dbus_state_changed (ZeitgeistNetworkManagerDBus* self,
                                                                GVariant* parameters);
static guint32 zeitgeist_network_manager_dbus_proxy_state (ZeitgeistNetworkManagerDBus* self,
                                                    GError** error);
static void zeitgeist_network_manager_dbus_proxy_zeitgeist_network_manager_dbus_interface_init (ZeitgeistNetworkManagerDBusIface* iface);
static void _dbus_zeitgeist_network_manager_dbus_state (ZeitgeistNetworkManagerDBus* self,
                                                 GVariant* _parameters_,
                                                 GDBusMethodInvocation* invocation);
static void zeitgeist_network_manager_dbus_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* zeitgeist_network_manager_dbus_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 zeitgeist_network_manager_dbus_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_zeitgeist_network_manager_dbus_state_changed (GObject* _sender,
                                                         guint32 state,
                                                         gpointer* _data);
static void _zeitgeist_network_manager_dbus_unregister_object (gpointer user_data);
static GType zeitgeist_connman_manager_dbus_get_type_once (void);
static void zeitgeist_connman_manager_dbus_proxy_g_signal (GDBusProxy* proxy,
                                                    const gchar* sender_name,
                                                    const gchar* signal_name,
                                                    GVariant* parameters);
static void _dbus_handle_zeitgeist_connman_manager_dbus_state_changed (ZeitgeistConnmanManagerDBus* self,
                                                                GVariant* parameters);
static gchar* zeitgeist_connman_manager_dbus_proxy_get_state (ZeitgeistConnmanManagerDBus* self,
                                                       GError** error);
static void zeitgeist_connman_manager_dbus_proxy_zeitgeist_connman_manager_dbus_interface_init (ZeitgeistConnmanManagerDBusIface* iface);
static void _dbus_zeitgeist_connman_manager_dbus_get_state (ZeitgeistConnmanManagerDBus* self,
                                                     GVariant* _parameters_,
                                                     GDBusMethodInvocation* invocation);
static void zeitgeist_connman_manager_dbus_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* zeitgeist_connman_manager_dbus_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 zeitgeist_connman_manager_dbus_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_zeitgeist_connman_manager_dbus_state_changed (GObject* _sender,
                                                         const gchar* state,
                                                         gpointer* _data);
static void _zeitgeist_connman_manager_dbus_unregister_object (gpointer user_data);
static void _vala_array_destroy (gpointer array,
                          gssize array_length,
                          GDestroyNotify destroy_func);
static void _vala_array_free (gpointer array,
                       gssize array_length,
                       GDestroyNotify destroy_func);
static inline gpointer _vala_memdup2 (gconstpointer mem,
                        gsize byte_size);

static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_delete_events_event_ids = {-1, "event_ids", "au", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_delete_events_result = {-1, "result", "(xx)", NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_delete_events_in[] = {&_zeitgeist_remote_log_dbus_arg_info_delete_events_event_ids, NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_delete_events_out[] = {&_zeitgeist_remote_log_dbus_arg_info_delete_events_result, NULL};
static const GDBusMethodInfo _zeitgeist_remote_log_dbus_method_info_delete_events = {-1, "DeleteEvents", (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_delete_events_in), (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_delete_events_out), NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_event_ids_time_range = {-1, "time_range", "(xx)", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_event_ids_event_templates = {-1, "event_templates", "a(asaasay)", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_event_ids_storage_state = {-1, "storage_state", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_event_ids_num_events = {-1, "num_events", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_event_ids_result_type = {-1, "result_type", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_event_ids_result = {-1, "result", "au", NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_find_event_ids_in[] = {&_zeitgeist_remote_log_dbus_arg_info_find_event_ids_time_range, &_zeitgeist_remote_log_dbus_arg_info_find_event_ids_event_templates, &_zeitgeist_remote_log_dbus_arg_info_find_event_ids_storage_state, &_zeitgeist_remote_log_dbus_arg_info_find_event_ids_num_events, &_zeitgeist_remote_log_dbus_arg_info_find_event_ids_result_type, NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_find_event_ids_out[] = {&_zeitgeist_remote_log_dbus_arg_info_find_event_ids_result, NULL};
static const GDBusMethodInfo _zeitgeist_remote_log_dbus_method_info_find_event_ids = {-1, "FindEventIds", (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_find_event_ids_in), (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_find_event_ids_out), NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_events_time_range = {-1, "time_range", "(xx)", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_events_event_templates = {-1, "event_templates", "a(asaasay)", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_events_storage_state = {-1, "storage_state", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_events_num_events = {-1, "num_events", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_events_result_type = {-1, "result_type", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_events_result = {-1, "result", "a(asaasay)", NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_find_events_in[] = {&_zeitgeist_remote_log_dbus_arg_info_find_events_time_range, &_zeitgeist_remote_log_dbus_arg_info_find_events_event_templates, &_zeitgeist_remote_log_dbus_arg_info_find_events_storage_state, &_zeitgeist_remote_log_dbus_arg_info_find_events_num_events, &_zeitgeist_remote_log_dbus_arg_info_find_events_result_type, NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_find_events_out[] = {&_zeitgeist_remote_log_dbus_arg_info_find_events_result, NULL};
static const GDBusMethodInfo _zeitgeist_remote_log_dbus_method_info_find_events = {-1, "FindEvents", (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_find_events_in), (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_find_events_out), NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_related_uris_time_range = {-1, "time_range", "(xx)", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_related_uris_event_templates = {-1, "event_templates", "a(asaasay)", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_related_uris_result_event_templates = {-1, "result_event_templates", "a(asaasay)", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_related_uris_storage_state = {-1, "storage_state", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_related_uris_num_events = {-1, "num_events", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_related_uris_result_type = {-1, "result_type", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_find_related_uris_result = {-1, "result", "as", NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_find_related_uris_in[] = {&_zeitgeist_remote_log_dbus_arg_info_find_related_uris_time_range, &_zeitgeist_remote_log_dbus_arg_info_find_related_uris_event_templates, &_zeitgeist_remote_log_dbus_arg_info_find_related_uris_result_event_templates, &_zeitgeist_remote_log_dbus_arg_info_find_related_uris_storage_state, &_zeitgeist_remote_log_dbus_arg_info_find_related_uris_num_events, &_zeitgeist_remote_log_dbus_arg_info_find_related_uris_result_type, NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_find_related_uris_out[] = {&_zeitgeist_remote_log_dbus_arg_info_find_related_uris_result, NULL};
static const GDBusMethodInfo _zeitgeist_remote_log_dbus_method_info_find_related_uris = {-1, "FindRelatedUris", (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_find_related_uris_in), (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_find_related_uris_out), NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_get_events_event_ids = {-1, "event_ids", "au", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_get_events_result = {-1, "result", "a(asaasay)", NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_get_events_in[] = {&_zeitgeist_remote_log_dbus_arg_info_get_events_event_ids, NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_get_events_out[] = {&_zeitgeist_remote_log_dbus_arg_info_get_events_result, NULL};
static const GDBusMethodInfo _zeitgeist_remote_log_dbus_method_info_get_events = {-1, "GetEvents", (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_get_events_in), (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_get_events_out), NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_insert_events_events = {-1, "events", "a(asaasay)", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_insert_events_result = {-1, "result", "au", NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_insert_events_in[] = {&_zeitgeist_remote_log_dbus_arg_info_insert_events_events, NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_insert_events_out[] = {&_zeitgeist_remote_log_dbus_arg_info_insert_events_result, NULL};
static const GDBusMethodInfo _zeitgeist_remote_log_dbus_method_info_insert_events = {-1, "InsertEvents", (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_insert_events_in), (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_insert_events_out), NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_install_monitor_monitor_path = {-1, "monitor_path", "o", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_install_monitor_time_range = {-1, "time_range", "(xx)", NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_install_monitor_event_templates = {-1, "event_templates", "a(asaasay)", NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_install_monitor_in[] = {&_zeitgeist_remote_log_dbus_arg_info_install_monitor_monitor_path, &_zeitgeist_remote_log_dbus_arg_info_install_monitor_time_range, &_zeitgeist_remote_log_dbus_arg_info_install_monitor_event_templates, NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_install_monitor_out[] = {NULL};
static const GDBusMethodInfo _zeitgeist_remote_log_dbus_method_info_install_monitor = {-1, "InstallMonitor", (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_install_monitor_in), (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_install_monitor_out), NULL};
static const GDBusArgInfo _zeitgeist_remote_log_dbus_arg_info_remove_monitor_monitor_path = {-1, "monitor_path", "o", NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_remove_monitor_in[] = {&_zeitgeist_remote_log_dbus_arg_info_remove_monitor_monitor_path, NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_remove_monitor_out[] = {NULL};
static const GDBusMethodInfo _zeitgeist_remote_log_dbus_method_info_remove_monitor = {-1, "RemoveMonitor", (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_remove_monitor_in), (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_remove_monitor_out), NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_quit_in[] = {NULL};
static const GDBusArgInfo * const _zeitgeist_remote_log_dbus_arg_info_quit_out[] = {NULL};
static const GDBusMethodInfo _zeitgeist_remote_log_dbus_method_info_quit = {-1, "Quit", (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_quit_in), (GDBusArgInfo **) (&_zeitgeist_remote_log_dbus_arg_info_quit_out), NULL};
static const GDBusMethodInfo * const _zeitgeist_remote_log_dbus_method_info[] = {&_zeitgeist_remote_log_dbus_method_info_delete_events, &_zeitgeist_remote_log_dbus_method_info_find_event_ids, &_zeitgeist_remote_log_dbus_method_info_find_events, &_zeitgeist_remote_log_dbus_method_info_find_related_uris, &_zeitgeist_remote_log_dbus_method_info_get_events, &_zeitgeist_remote_log_dbus_method_info_insert_events, &_zeitgeist_remote_log_dbus_method_info_install_monitor, &_zeitgeist_remote_log_dbus_method_info_remove_monitor, &_zeitgeist_remote_log_dbus_method_info_quit, NULL};
static const GDBusSignalInfo * const _zeitgeist_remote_log_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo _zeitgeist_remote_log_dbus_property_info_extensions = {-1, "extensions", "as", G_DBUS_PROPERTY_INFO_FLAGS_READABLE, NULL};
static const GDBusPropertyInfo _zeitgeist_remote_log_dbus_property_info_version = {-1, "version", "(iii)", G_DBUS_PROPERTY_INFO_FLAGS_READABLE, NULL};
static const GDBusPropertyInfo _zeitgeist_remote_log_dbus_property_info_datapath = {-1, "datapath", "s", G_DBUS_PROPERTY_INFO_FLAGS_READABLE, NULL};
static const GDBusPropertyInfo * const _zeitgeist_remote_log_dbus_property_info[] = {&_zeitgeist_remote_log_dbus_property_info_extensions, &_zeitgeist_remote_log_dbus_property_info_version, &_zeitgeist_remote_log_dbus_property_info_datapath, NULL};
static const GDBusInterfaceInfo _zeitgeist_remote_log_dbus_interface_info = {-1, "org.gnome.zeitgeist.Log", (GDBusMethodInfo **) (&_zeitgeist_remote_log_dbus_method_info), (GDBusSignalInfo **) (&_zeitgeist_remote_log_dbus_signal_info), (GDBusPropertyInfo **) (&_zeitgeist_remote_log_dbus_property_info), NULL};
static const GDBusInterfaceVTable _zeitgeist_remote_log_dbus_interface_vtable = {zeitgeist_remote_log_dbus_interface_method_call, zeitgeist_remote_log_dbus_interface_get_property, zeitgeist_remote_log_dbus_interface_set_property};
static const GDBusArgInfo _zeitgeist_remote_monitor_dbus_arg_info_notify_insert_time_range = {-1, "time_range", "(xx)", NULL};
static const GDBusArgInfo _zeitgeist_remote_monitor_dbus_arg_info_notify_insert_events = {-1, "events", "a(asaasay)", NULL};
static const GDBusArgInfo * const _zeitgeist_remote_monitor_dbus_arg_info_notify_insert_in[] = {&_zeitgeist_remote_monitor_dbus_arg_info_notify_insert_time_range, &_zeitgeist_remote_monitor_dbus_arg_info_notify_insert_events, NULL};
static const GDBusArgInfo * const _zeitgeist_remote_monitor_dbus_arg_info_notify_insert_out[] = {NULL};
static const GDBusMethodInfo _zeitgeist_remote_monitor_dbus_method_info_notify_insert = {-1, "NotifyInsert", (GDBusArgInfo **) (&_zeitgeist_remote_monitor_dbus_arg_info_notify_insert_in), (GDBusArgInfo **) (&_zeitgeist_remote_monitor_dbus_arg_info_notify_insert_out), NULL};
static const GDBusArgInfo _zeitgeist_remote_monitor_dbus_arg_info_notify_delete_time_range = {-1, "time_range", "(xx)", NULL};
static const GDBusArgInfo _zeitgeist_remote_monitor_dbus_arg_info_notify_delete_event_ids = {-1, "event_ids", "au", NULL};
static const GDBusArgInfo * const _zeitgeist_remote_monitor_dbus_arg_info_notify_delete_in[] = {&_zeitgeist_remote_monitor_dbus_arg_info_notify_delete_time_range, &_zeitgeist_remote_monitor_dbus_arg_info_notify_delete_event_ids, NULL};
static const GDBusArgInfo * const _zeitgeist_remote_monitor_dbus_arg_info_notify_delete_out[] = {NULL};
static const GDBusMethodInfo _zeitgeist_remote_monitor_dbus_method_info_notify_delete = {-1, "NotifyDelete", (GDBusArgInfo **) (&_zeitgeist_remote_monitor_dbus_arg_info_notify_delete_in), (GDBusArgInfo **) (&_zeitgeist_remote_monitor_dbus_arg_info_notify_delete_out), NULL};
static const GDBusMethodInfo * const _zeitgeist_remote_monitor_dbus_method_info[] = {&_zeitgeist_remote_monitor_dbus_method_info_notify_insert, &_zeitgeist_remote_monitor_dbus_method_info_notify_delete, NULL};
static const GDBusSignalInfo * const _zeitgeist_remote_monitor_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo * const _zeitgeist_remote_monitor_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _zeitgeist_remote_monitor_dbus_interface_info = {-1, "org.gnome.zeitgeist.Monitor", (GDBusMethodInfo **) (&_zeitgeist_remote_monitor_dbus_method_info), (GDBusSignalInfo **) (&_zeitgeist_remote_monitor_dbus_signal_info), (GDBusPropertyInfo **) (&_zeitgeist_remote_monitor_dbus_property_info), NULL};
static const GDBusInterfaceVTable _zeitgeist_remote_monitor_dbus_interface_vtable = {zeitgeist_remote_monitor_dbus_interface_method_call, zeitgeist_remote_monitor_dbus_interface_get_property, zeitgeist_remote_monitor_dbus_interface_set_property};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_query_string = {-1, "query_string", "s", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_time_range = {-1, "time_range", "(xx)", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_filter_templates = {-1, "filter_templates", "a(asaasay)", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_offset = {-1, "offset", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_count = {-1, "count", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_result_type = {-1, "result_type", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_events = {-1, "events", "a(asaasay)", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_matches = {-1, "matches", "u", NULL};
static const GDBusArgInfo * const _zeitgeist_remote_simple_indexer_dbus_arg_info_search_in[] = {&_zeitgeist_remote_simple_indexer_dbus_arg_info_search_query_string, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_time_range, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_filter_templates, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_offset, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_count, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_result_type, NULL};
static const GDBusArgInfo * const _zeitgeist_remote_simple_indexer_dbus_arg_info_search_out[] = {&_zeitgeist_remote_simple_indexer_dbus_arg_info_search_events, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_matches, NULL};
static const GDBusMethodInfo _zeitgeist_remote_simple_indexer_dbus_method_info_search = {-1, "Search", (GDBusArgInfo **) (&_zeitgeist_remote_simple_indexer_dbus_arg_info_search_in), (GDBusArgInfo **) (&_zeitgeist_remote_simple_indexer_dbus_arg_info_search_out), NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_query_string = {-1, "query_string", "s", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_time_range = {-1, "time_range", "(xx)", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_filter_templates = {-1, "filter_templates", "a(asaasay)", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_storage_state = {-1, "storage_state", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_offset = {-1, "offset", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_count = {-1, "count", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_result_type = {-1, "result_type", "u", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_events = {-1, "events", "a(asaasay)", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_relevancies = {-1, "relevancies", "ad", NULL};
static const GDBusArgInfo _zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_matches = {-1, "matches", "u", NULL};
static const GDBusArgInfo * const _zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_in[] = {&_zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_query_string, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_time_range, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_filter_templates, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_storage_state, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_offset, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_count, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_result_type, NULL};
static const GDBusArgInfo * const _zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_out[] = {&_zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_events, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_relevancies, &_zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_matches, NULL};
static const GDBusMethodInfo _zeitgeist_remote_simple_indexer_dbus_method_info_search_with_relevancies = {-1, "SearchWithRelevancies", (GDBusArgInfo **) (&_zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_in), (GDBusArgInfo **) (&_zeitgeist_remote_simple_indexer_dbus_arg_info_search_with_relevancies_out), NULL};
static const GDBusMethodInfo * const _zeitgeist_remote_simple_indexer_dbus_method_info[] = {&_zeitgeist_remote_simple_indexer_dbus_method_info_search, &_zeitgeist_remote_simple_indexer_dbus_method_info_search_with_relevancies, NULL};
static const GDBusSignalInfo * const _zeitgeist_remote_simple_indexer_dbus_signal_info[] = {NULL};
static const GDBusPropertyInfo * const _zeitgeist_remote_simple_indexer_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _zeitgeist_remote_simple_indexer_dbus_interface_info = {-1, "org.gnome.zeitgeist.Index", (GDBusMethodInfo **) (&_zeitgeist_remote_simple_indexer_dbus_method_info), (GDBusSignalInfo **) (&_zeitgeist_remote_simple_indexer_dbus_signal_info), (GDBusPropertyInfo **) (&_zeitgeist_remote_simple_indexer_dbus_property_info), NULL};
static const GDBusInterfaceVTable _zeitgeist_remote_simple_indexer_dbus_interface_vtable = {zeitgeist_remote_simple_indexer_dbus_interface_method_call, zeitgeist_remote_simple_indexer_dbus_interface_get_property, zeitgeist_remote_simple_indexer_dbus_interface_set_property};
static const GDBusArgInfo _zeitgeist_network_manager_dbus_dbus_arg_info_state_result = {-1, "result", "u", NULL};
static const GDBusArgInfo * const _zeitgeist_network_manager_dbus_dbus_arg_info_state_in[] = {NULL};
static const GDBusArgInfo * const _zeitgeist_network_manager_dbus_dbus_arg_info_state_out[] = {&_zeitgeist_network_manager_dbus_dbus_arg_info_state_result, NULL};
static const GDBusMethodInfo _zeitgeist_network_manager_dbus_dbus_method_info_state = {-1, "state", (GDBusArgInfo **) (&_zeitgeist_network_manager_dbus_dbus_arg_info_state_in), (GDBusArgInfo **) (&_zeitgeist_network_manager_dbus_dbus_arg_info_state_out), NULL};
static const GDBusMethodInfo * const _zeitgeist_network_manager_dbus_dbus_method_info[] = {&_zeitgeist_network_manager_dbus_dbus_method_info_state, NULL};
static const GDBusArgInfo _zeitgeist_network_manager_dbus_dbus_arg_info_state_changed_state = {-1, "state", "u", NULL};
static const GDBusArgInfo * const _zeitgeist_network_manager_dbus_dbus_arg_info_state_changed[] = {&_zeitgeist_network_manager_dbus_dbus_arg_info_state_changed_state, NULL};
static const GDBusSignalInfo _zeitgeist_network_manager_dbus_dbus_signal_info_state_changed = {-1, "StateChanged", (GDBusArgInfo **) (&_zeitgeist_network_manager_dbus_dbus_arg_info_state_changed), NULL};
static const GDBusSignalInfo * const _zeitgeist_network_manager_dbus_dbus_signal_info[] = {&_zeitgeist_network_manager_dbus_dbus_signal_info_state_changed, NULL};
static const GDBusPropertyInfo * const _zeitgeist_network_manager_dbus_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _zeitgeist_network_manager_dbus_dbus_interface_info = {-1, "org.freedesktop.NetworkManager", (GDBusMethodInfo **) (&_zeitgeist_network_manager_dbus_dbus_method_info), (GDBusSignalInfo **) (&_zeitgeist_network_manager_dbus_dbus_signal_info), (GDBusPropertyInfo **) (&_zeitgeist_network_manager_dbus_dbus_property_info), NULL};
static const GDBusInterfaceVTable _zeitgeist_network_manager_dbus_dbus_interface_vtable = {zeitgeist_network_manager_dbus_dbus_interface_method_call, zeitgeist_network_manager_dbus_dbus_interface_get_property, zeitgeist_network_manager_dbus_dbus_interface_set_property};
static const GDBusArgInfo _zeitgeist_connman_manager_dbus_dbus_arg_info_get_state_result = {-1, "result", "s", NULL};
static const GDBusArgInfo * const _zeitgeist_connman_manager_dbus_dbus_arg_info_get_state_in[] = {NULL};
static const GDBusArgInfo * const _zeitgeist_connman_manager_dbus_dbus_arg_info_get_state_out[] = {&_zeitgeist_connman_manager_dbus_dbus_arg_info_get_state_result, NULL};
static const GDBusMethodInfo _zeitgeist_connman_manager_dbus_dbus_method_info_get_state = {-1, "GetState", (GDBusArgInfo **) (&_zeitgeist_connman_manager_dbus_dbus_arg_info_get_state_in), (GDBusArgInfo **) (&_zeitgeist_connman_manager_dbus_dbus_arg_info_get_state_out), NULL};
static const GDBusMethodInfo * const _zeitgeist_connman_manager_dbus_dbus_method_info[] = {&_zeitgeist_connman_manager_dbus_dbus_method_info_get_state, NULL};
static const GDBusArgInfo _zeitgeist_connman_manager_dbus_dbus_arg_info_state_changed_state = {-1, "state", "s", NULL};
static const GDBusArgInfo * const _zeitgeist_connman_manager_dbus_dbus_arg_info_state_changed[] = {&_zeitgeist_connman_manager_dbus_dbus_arg_info_state_changed_state, NULL};
static const GDBusSignalInfo _zeitgeist_connman_manager_dbus_dbus_signal_info_state_changed = {-1, "StateChanged", (GDBusArgInfo **) (&_zeitgeist_connman_manager_dbus_dbus_arg_info_state_changed), NULL};
static const GDBusSignalInfo * const _zeitgeist_connman_manager_dbus_dbus_signal_info[] = {&_zeitgeist_connman_manager_dbus_dbus_signal_info_state_changed, NULL};
static const GDBusPropertyInfo * const _zeitgeist_connman_manager_dbus_dbus_property_info[] = {NULL};
static const GDBusInterfaceInfo _zeitgeist_connman_manager_dbus_dbus_interface_info = {-1, "net.connman.Manager", (GDBusMethodInfo **) (&_zeitgeist_connman_manager_dbus_dbus_method_info), (GDBusSignalInfo **) (&_zeitgeist_connman_manager_dbus_dbus_signal_info), (GDBusPropertyInfo **) (&_zeitgeist_connman_manager_dbus_dbus_property_info), NULL};
static const GDBusInterfaceVTable _zeitgeist_connman_manager_dbus_dbus_interface_vtable = {zeitgeist_connman_manager_dbus_dbus_interface_method_call, zeitgeist_connman_manager_dbus_dbus_interface_get_property, zeitgeist_connman_manager_dbus_dbus_interface_set_property};

ZeitgeistVersionStruct*
zeitgeist_version_struct_dup (const ZeitgeistVersionStruct* self)
{
	ZeitgeistVersionStruct* dup;
	dup = g_new0 (ZeitgeistVersionStruct, 1);
	memcpy (dup, self, sizeof (ZeitgeistVersionStruct));
	return dup;
}

void
zeitgeist_version_struct_free (ZeitgeistVersionStruct* self)
{
	g_free (self);
}

static GType
zeitgeist_version_struct_get_type_once (void)
{
	GType zeitgeist_version_struct_type_id;
	zeitgeist_version_struct_type_id = g_boxed_type_register_static ("ZeitgeistVersionStruct", (GBoxedCopyFunc) zeitgeist_version_struct_dup, (GBoxedFreeFunc) zeitgeist_version_struct_free);
	return zeitgeist_version_struct_type_id;
}

GType
zeitgeist_version_struct_get_type (void)
{
	static volatile gsize zeitgeist_version_struct_type_id__once = 0;
	if (g_once_init_enter (&zeitgeist_version_struct_type_id__once)) {
		GType zeitgeist_version_struct_type_id;
		zeitgeist_version_struct_type_id = zeitgeist_version_struct_get_type_once ();
		g_once_init_leave (&zeitgeist_version_struct_type_id__once, zeitgeist_version_struct_type_id);
	}
	return zeitgeist_version_struct_type_id__once;
}

void
zeitgeist_remote_log_delete_events (ZeitgeistRemoteLog* self,
                                    guint32* event_ids,
                                    gint event_ids_length1,
                                    GCancellable* cancellable,
                                    const char* sender,
                                    GAsyncReadyCallback _callback_,
                                    gpointer _user_data_)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->delete_events) {
		_iface_->delete_events (self, event_ids, event_ids_length1, cancellable, sender, _callback_, _user_data_);
	}
}

GVariant*
zeitgeist_remote_log_delete_events_finish (ZeitgeistRemoteLog* self,
                                           GAsyncResult* _res_,
                                           GError** error)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->delete_events_finish) {
		return _iface_->delete_events_finish (self, _res_, error);
	}
	return NULL;
}

void
zeitgeist_remote_log_find_event_ids (ZeitgeistRemoteLog* self,
                                     GVariant* time_range,
                                     GVariant* event_templates,
                                     guint storage_state,
                                     guint num_events,
                                     guint result_type,
                                     GCancellable* cancellable,
                                     const char* sender,
                                     GAsyncReadyCallback _callback_,
                                     gpointer _user_data_)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->find_event_ids) {
		_iface_->find_event_ids (self, time_range, event_templates, storage_state, num_events, result_type, cancellable, sender, _callback_, _user_data_);
	}
}

guint32*
zeitgeist_remote_log_find_event_ids_finish (ZeitgeistRemoteLog* self,
                                            GAsyncResult* _res_,
                                            gint* result_length1,
                                            GError** error)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->find_event_ids_finish) {
		return _iface_->find_event_ids_finish (self, _res_, result_length1, error);
	}
	return NULL;
}

void
zeitgeist_remote_log_find_events (ZeitgeistRemoteLog* self,
                                  GVariant* time_range,
                                  GVariant* event_templates,
                                  guint storage_state,
                                  guint num_events,
                                  guint result_type,
                                  GCancellable* cancellable,
                                  const char* sender,
                                  GAsyncReadyCallback _callback_,
                                  gpointer _user_data_)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->find_events) {
		_iface_->find_events (self, time_range, event_templates, storage_state, num_events, result_type, cancellable, sender, _callback_, _user_data_);
	}
}

GVariant*
zeitgeist_remote_log_find_events_finish (ZeitgeistRemoteLog* self,
                                         GAsyncResult* _res_,
                                         GError** error)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->find_events_finish) {
		return _iface_->find_events_finish (self, _res_, error);
	}
	return NULL;
}

void
zeitgeist_remote_log_find_related_uris (ZeitgeistRemoteLog* self,
                                        GVariant* time_range,
                                        GVariant* event_templates,
                                        GVariant* result_event_templates,
                                        guint storage_state,
                                        guint num_events,
                                        guint result_type,
                                        GCancellable* cancellable,
                                        const char* sender,
                                        GAsyncReadyCallback _callback_,
                                        gpointer _user_data_)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->find_related_uris) {
		_iface_->find_related_uris (self, time_range, event_templates, result_event_templates, storage_state, num_events, result_type, cancellable, sender, _callback_, _user_data_);
	}
}

gchar**
zeitgeist_remote_log_find_related_uris_finish (ZeitgeistRemoteLog* self,
                                               GAsyncResult* _res_,
                                               gint* result_length1,
                                               GError** error)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->find_related_uris_finish) {
		return _iface_->find_related_uris_finish (self, _res_, result_length1, error);
	}
	return NULL;
}

void
zeitgeist_remote_log_get_events (ZeitgeistRemoteLog* self,
                                 guint32* event_ids,
                                 gint event_ids_length1,
                                 GCancellable* cancellable,
                                 const char* sender,
                                 GAsyncReadyCallback _callback_,
                                 gpointer _user_data_)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->get_events) {
		_iface_->get_events (self, event_ids, event_ids_length1, cancellable, sender, _callback_, _user_data_);
	}
}

GVariant*
zeitgeist_remote_log_get_events_finish (ZeitgeistRemoteLog* self,
                                        GAsyncResult* _res_,
                                        GError** error)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->get_events_finish) {
		return _iface_->get_events_finish (self, _res_, error);
	}
	return NULL;
}

void
zeitgeist_remote_log_insert_events (ZeitgeistRemoteLog* self,
                                    GVariant* events,
                                    GCancellable* cancellable,
                                    const char* sender,
                                    GAsyncReadyCallback _callback_,
                                    gpointer _user_data_)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->insert_events) {
		_iface_->insert_events (self, events, cancellable, sender, _callback_, _user_data_);
	}
}

guint32*
zeitgeist_remote_log_insert_events_finish (ZeitgeistRemoteLog* self,
                                           GAsyncResult* _res_,
                                           gint* result_length1,
                                           GError** error)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->insert_events_finish) {
		return _iface_->insert_events_finish (self, _res_, result_length1, error);
	}
	return NULL;
}

void
zeitgeist_remote_log_install_monitor (ZeitgeistRemoteLog* self,
                                      const char* monitor_path,
                                      GVariant* time_range,
                                      GVariant* event_templates,
                                      const char* owner,
                                      GAsyncReadyCallback _callback_,
                                      gpointer _user_data_)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->install_monitor) {
		_iface_->install_monitor (self, monitor_path, time_range, event_templates, owner, _callback_, _user_data_);
	}
}

void
zeitgeist_remote_log_install_monitor_finish (ZeitgeistRemoteLog* self,
                                             GAsyncResult* _res_,
                                             GError** error)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->install_monitor_finish) {
		_iface_->install_monitor_finish (self, _res_, error);
	}
}

void
zeitgeist_remote_log_remove_monitor (ZeitgeistRemoteLog* self,
                                     const char* monitor_path,
                                     const char* owner,
                                     GAsyncReadyCallback _callback_,
                                     gpointer _user_data_)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->remove_monitor) {
		_iface_->remove_monitor (self, monitor_path, owner, _callback_, _user_data_);
	}
}

void
zeitgeist_remote_log_remove_monitor_finish (ZeitgeistRemoteLog* self,
                                            GAsyncResult* _res_,
                                            GError** error)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->remove_monitor_finish) {
		_iface_->remove_monitor_finish (self, _res_, error);
	}
}

void
zeitgeist_remote_log_quit (ZeitgeistRemoteLog* self,
                           GCancellable* cancellable,
                           GAsyncReadyCallback _callback_,
                           gpointer _user_data_)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->quit) {
		_iface_->quit (self, cancellable, _callback_, _user_data_);
	}
}

void
zeitgeist_remote_log_quit_finish (ZeitgeistRemoteLog* self,
                                  GAsyncResult* _res_,
                                  GError** error)
{
	ZeitgeistRemoteLogIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->quit_finish) {
		_iface_->quit_finish (self, _res_, error);
	}
}

gchar**
zeitgeist_remote_log_get_extensions (ZeitgeistRemoteLog* self,
                                     gint* result_length1)
{
	ZeitgeistRemoteLogIface* _iface_;
	g_return_val_if_fail (self != NULL, NULL);
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->get_extensions) {
		return _iface_->get_extensions (self, result_length1);
	}
	return NULL;
}

void
zeitgeist_remote_log_get_version (ZeitgeistRemoteLog* self,
                                  ZeitgeistVersionStruct * result)
{
	ZeitgeistRemoteLogIface* _iface_;
	g_return_if_fail (self != NULL);
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->get_version) {
		_iface_->get_version (self, result);
	}
	return;
}

gchar*
zeitgeist_remote_log_get_datapath (ZeitgeistRemoteLog* self)
{
	ZeitgeistRemoteLogIface* _iface_;
	g_return_val_if_fail (self != NULL, NULL);
	_iface_ = ZEITGEIST_REMOTE_LOG_GET_INTERFACE (self);
	if (_iface_->get_datapath) {
		return _iface_->get_datapath (self);
	}
	return NULL;
}

static void
zeitgeist_remote_log_default_init (ZeitgeistRemoteLogIface * iface,
                                   gpointer iface_data)
{
}

static GType
zeitgeist_remote_log_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ZeitgeistRemoteLogIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) zeitgeist_remote_log_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
	GType zeitgeist_remote_log_type_id;
	zeitgeist_remote_log_type_id = g_type_register_static (G_TYPE_INTERFACE, "ZeitgeistRemoteLog", &g_define_type_info, 0);
	g_type_interface_add_prerequisite (zeitgeist_remote_log_type_id, G_TYPE_OBJECT);
	g_type_set_qdata (zeitgeist_remote_log_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) zeitgeist_remote_log_proxy_get_type);
	g_type_set_qdata (zeitgeist_remote_log_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.gnome.zeitgeist.Log");
	g_type_set_qdata (zeitgeist_remote_log_type_id, g_quark_from_static_string ("vala-dbus-interface-info"), (void*) (&_zeitgeist_remote_log_dbus_interface_info));
	g_type_set_qdata (zeitgeist_remote_log_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) zeitgeist_remote_log_register_object);
	return zeitgeist_remote_log_type_id;
}

GType
zeitgeist_remote_log_get_type (void)
{
	static volatile gsize zeitgeist_remote_log_type_id__once = 0;
	if (g_once_init_enter (&zeitgeist_remote_log_type_id__once)) {
		GType zeitgeist_remote_log_type_id;
		zeitgeist_remote_log_type_id = zeitgeist_remote_log_get_type_once ();
		g_once_init_leave (&zeitgeist_remote_log_type_id__once, zeitgeist_remote_log_type_id);
	}
	return zeitgeist_remote_log_type_id__once;
}

G_DEFINE_TYPE_EXTENDED (ZeitgeistRemoteLogProxy, zeitgeist_remote_log_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (ZEITGEIST_TYPE_REMOTE_LOG, zeitgeist_remote_log_proxy_zeitgeist_remote_log_interface_init) )
static void
zeitgeist_remote_log_proxy_class_init (ZeitgeistRemoteLogProxyClass* klass)
{
	G_DBUS_PROXY_CLASS (klass)->g_signal = zeitgeist_remote_log_proxy_g_signal;
}

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

static void
zeitgeist_remote_log_proxy_init (ZeitgeistRemoteLogProxy* self)
{
	g_dbus_proxy_set_interface_info (G_DBUS_PROXY (self), (GDBusInterfaceInfo *) (&_zeitgeist_remote_log_dbus_interface_info));
}

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

static void
zeitgeist_remote_log_proxy_delete_events_async (ZeitgeistRemoteLog* self,
                                                guint32* event_ids,
                                                gint event_ids_length1,
                                                GCancellable* cancellable,
                                                const char* sender,
                                                GAsyncReadyCallback _callback_,
                                                gpointer _user_data_)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	guint32* _tmp11_;
	GVariantBuilder _tmp12_;
	gint _tmp13_;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.gnome.zeitgeist.Log", "DeleteEvents");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_tmp11_ = event_ids;
	g_variant_builder_init (&_tmp12_, G_VARIANT_TYPE ("au"));
	for (_tmp13_ = 0; _tmp13_ < event_ids_length1; _tmp13_++) {
		g_variant_builder_add_value (&_tmp12_, g_variant_new_uint32 (*_tmp11_));
		_tmp11_++;
	}
	g_variant_builder_add_value (&_arguments_builder, g_variant_builder_end (&_tmp12_));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	if (_callback_ != NULL) {
		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, cancellable, _vala_g_async_ready_callback, g_task_new ((GObject *) self, NULL, _callback_, _user_data_));
	} else {
		g_dbus_message_set_flags (_message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
		g_dbus_connection_send_message (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	}
	g_object_unref (_message);
}

static GVariant*
zeitgeist_remote_log_proxy_delete_events_finish (ZeitgeistRemoteLog* self,
                                                 GAsyncResult* _res_,
                                                 GError** error)
{
	GAsyncResult *_inner_res;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	GVariant* _result = NULL;
	_inner_res = g_task_propagate_pointer ((GTask *) _res_, NULL);
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), _inner_res, error);
	g_object_unref (_inner_res);
	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 = g_variant_iter_next_value (&_reply_iter);
	g_object_unref (_reply_message);
	return _result;
}

static void
zeitgeist_remote_log_proxy_find_event_ids_async (ZeitgeistRemoteLog* self,
                                                 GVariant* time_range,
                                                 GVariant* event_templates,
                                                 guint storage_state,
                                                 guint num_events,
                                                 guint result_type,
                                                 GCancellable* cancellable,
                                                 const char* sender,
                                                 GAsyncReadyCallback _callback_,
                                                 gpointer _user_data_)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.gnome.zeitgeist.Log", "FindEventIds");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, time_range);
	g_variant_builder_add_value (&_arguments_builder, event_templates);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (storage_state));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (num_events));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (result_type));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	if (_callback_ != NULL) {
		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, cancellable, _vala_g_async_ready_callback, g_task_new ((GObject *) self, NULL, _callback_, _user_data_));
	} else {
		g_dbus_message_set_flags (_message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
		g_dbus_connection_send_message (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	}
	g_object_unref (_message);
}

static guint32*
zeitgeist_remote_log_proxy_find_event_ids_finish (ZeitgeistRemoteLog* self,
                                                  GAsyncResult* _res_,
                                                  gint* result_length1,
                                                  GError** error)
{
	GAsyncResult *_inner_res;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint32* _result = NULL;
	gint _result_length1;
	GVariant* _tmp14_;
	guint32* _tmp15_;
	gint _tmp15__length;
	gint _tmp15__size;
	gint _tmp15__length1;
	GVariantIter _tmp16_;
	GVariant* _tmp17_;
	_inner_res = g_task_propagate_pointer ((GTask *) _res_, NULL);
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), _inner_res, error);
	g_object_unref (_inner_res);
	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;
	_tmp14_ = g_variant_iter_next_value (&_reply_iter);
	_tmp15_ = g_new (guint32, 5);
	_tmp15__length = 0;
	_tmp15__size = 4;
	_tmp15__length1 = 0;
	g_variant_iter_init (&_tmp16_, _tmp14_);
	for (; (_tmp17_ = g_variant_iter_next_value (&_tmp16_)) != NULL; _tmp15__length1++) {
		if (_tmp15__size == _tmp15__length) {
			_tmp15__size = 2 * _tmp15__size;
			_tmp15_ = g_renew (guint32, _tmp15_, _tmp15__size + 1);
		}
		_tmp15_[_tmp15__length++] = g_variant_get_uint32 (_tmp17_);
		g_variant_unref (_tmp17_);
	}
	_result_length1 = _tmp15__length1;
	_result = _tmp15_;
	g_variant_unref (_tmp14_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}

static void
zeitgeist_remote_log_proxy_find_events_async (ZeitgeistRemoteLog* self,
                                              GVariant* time_range,
                                              GVariant* event_templates,
                                              guint storage_state,
                                              guint num_events,
                                              guint result_type,
                                              GCancellable* cancellable,
                                              const char* sender,
                                              GAsyncReadyCallback _callback_,
                                              gpointer _user_data_)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.gnome.zeitgeist.Log", "FindEvents");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, time_range);
	g_variant_builder_add_value (&_arguments_builder, event_templates);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (storage_state));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (num_events));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (result_type));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	if (_callback_ != NULL) {
		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, cancellable, _vala_g_async_ready_callback, g_task_new ((GObject *) self, NULL, _callback_, _user_data_));
	} else {
		g_dbus_message_set_flags (_message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
		g_dbus_connection_send_message (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	}
	g_object_unref (_message);
}

static GVariant*
zeitgeist_remote_log_proxy_find_events_finish (ZeitgeistRemoteLog* self,
                                               GAsyncResult* _res_,
                                               GError** error)
{
	GAsyncResult *_inner_res;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	GVariant* _result = NULL;
	_inner_res = g_task_propagate_pointer ((GTask *) _res_, NULL);
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), _inner_res, error);
	g_object_unref (_inner_res);
	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 = g_variant_iter_next_value (&_reply_iter);
	g_object_unref (_reply_message);
	return _result;
}

static void
zeitgeist_remote_log_proxy_find_related_uris_async (ZeitgeistRemoteLog* self,
                                                    GVariant* time_range,
                                                    GVariant* event_templates,
                                                    GVariant* result_event_templates,
                                                    guint storage_state,
                                                    guint num_events,
                                                    guint result_type,
                                                    GCancellable* cancellable,
                                                    const char* sender,
                                                    GAsyncReadyCallback _callback_,
                                                    gpointer _user_data_)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.gnome.zeitgeist.Log", "FindRelatedUris");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, time_range);
	g_variant_builder_add_value (&_arguments_builder, event_templates);
	g_variant_builder_add_value (&_arguments_builder, result_event_templates);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (storage_state));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (num_events));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (result_type));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	if (_callback_ != NULL) {
		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, cancellable, _vala_g_async_ready_callback, g_task_new ((GObject *) self, NULL, _callback_, _user_data_));
	} else {
		g_dbus_message_set_flags (_message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
		g_dbus_connection_send_message (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	}
	g_object_unref (_message);
}

static gchar**
zeitgeist_remote_log_proxy_find_related_uris_finish (ZeitgeistRemoteLog* self,
                                                     GAsyncResult* _res_,
                                                     gint* result_length1,
                                                     GError** error)
{
	GAsyncResult *_inner_res;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar** _result = NULL;
	gint _result_length1;
	GVariant* _tmp18_;
	gchar** _tmp19_;
	gint _tmp19__length;
	gint _tmp19__size;
	gint _tmp19__length1;
	GVariantIter _tmp20_;
	GVariant* _tmp21_;
	_inner_res = g_task_propagate_pointer ((GTask *) _res_, NULL);
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), _inner_res, error);
	g_object_unref (_inner_res);
	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;
	_tmp18_ = g_variant_iter_next_value (&_reply_iter);
	_tmp19_ = g_new (gchar*, 5);
	_tmp19__length = 0;
	_tmp19__size = 4;
	_tmp19__length1 = 0;
	g_variant_iter_init (&_tmp20_, _tmp18_);
	for (; (_tmp21_ = g_variant_iter_next_value (&_tmp20_)) != NULL; _tmp19__length1++) {
		if (_tmp19__size == _tmp19__length) {
			_tmp19__size = 2 * _tmp19__size;
			_tmp19_ = g_renew (gchar*, _tmp19_, _tmp19__size + 1);
		}
		_tmp19_[_tmp19__length++] = g_variant_dup_string (_tmp21_, NULL);
		g_variant_unref (_tmp21_);
	}
	_result_length1 = _tmp19__length1;
	_tmp19_[_tmp19__length] = NULL;
	_result = _tmp19_;
	g_variant_unref (_tmp18_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}

static void
zeitgeist_remote_log_proxy_get_events_async (ZeitgeistRemoteLog* self,
                                             guint32* event_ids,
                                             gint event_ids_length1,
                                             GCancellable* cancellable,
                                             const char* sender,
                                             GAsyncReadyCallback _callback_,
                                             gpointer _user_data_)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	guint32* _tmp22_;
	GVariantBuilder _tmp23_;
	gint _tmp24_;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.gnome.zeitgeist.Log", "GetEvents");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_tmp22_ = event_ids;
	g_variant_builder_init (&_tmp23_, G_VARIANT_TYPE ("au"));
	for (_tmp24_ = 0; _tmp24_ < event_ids_length1; _tmp24_++) {
		g_variant_builder_add_value (&_tmp23_, g_variant_new_uint32 (*_tmp22_));
		_tmp22_++;
	}
	g_variant_builder_add_value (&_arguments_builder, g_variant_builder_end (&_tmp23_));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	if (_callback_ != NULL) {
		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, cancellable, _vala_g_async_ready_callback, g_task_new ((GObject *) self, NULL, _callback_, _user_data_));
	} else {
		g_dbus_message_set_flags (_message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
		g_dbus_connection_send_message (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	}
	g_object_unref (_message);
}

static GVariant*
zeitgeist_remote_log_proxy_get_events_finish (ZeitgeistRemoteLog* self,
                                              GAsyncResult* _res_,
                                              GError** error)
{
	GAsyncResult *_inner_res;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	GVariant* _result = NULL;
	_inner_res = g_task_propagate_pointer ((GTask *) _res_, NULL);
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), _inner_res, error);
	g_object_unref (_inner_res);
	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 = g_variant_iter_next_value (&_reply_iter);
	g_object_unref (_reply_message);
	return _result;
}

static void
zeitgeist_remote_log_proxy_insert_events_async (ZeitgeistRemoteLog* self,
                                                GVariant* events,
                                                GCancellable* cancellable,
                                                const char* sender,
                                                GAsyncReadyCallback _callback_,
                                                gpointer _user_data_)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.gnome.zeitgeist.Log", "InsertEvents");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, events);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	if (_callback_ != NULL) {
		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, cancellable, _vala_g_async_ready_callback, g_task_new ((GObject *) self, NULL, _callback_, _user_data_));
	} else {
		g_dbus_message_set_flags (_message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
		g_dbus_connection_send_message (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	}
	g_object_unref (_message);
}

static guint32*
zeitgeist_remote_log_proxy_insert_events_finish (ZeitgeistRemoteLog* self,
                                                 GAsyncResult* _res_,
                                                 gint* result_length1,
                                                 GError** error)
{
	GAsyncResult *_inner_res;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint32* _result = NULL;
	gint _result_length1;
	GVariant* _tmp25_;
	guint32* _tmp26_;
	gint _tmp26__length;
	gint _tmp26__size;
	gint _tmp26__length1;
	GVariantIter _tmp27_;
	GVariant* _tmp28_;
	_inner_res = g_task_propagate_pointer ((GTask *) _res_, NULL);
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), _inner_res, error);
	g_object_unref (_inner_res);
	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;
	_tmp25_ = g_variant_iter_next_value (&_reply_iter);
	_tmp26_ = g_new (guint32, 5);
	_tmp26__length = 0;
	_tmp26__size = 4;
	_tmp26__length1 = 0;
	g_variant_iter_init (&_tmp27_, _tmp25_);
	for (; (_tmp28_ = g_variant_iter_next_value (&_tmp27_)) != NULL; _tmp26__length1++) {
		if (_tmp26__size == _tmp26__length) {
			_tmp26__size = 2 * _tmp26__size;
			_tmp26_ = g_renew (guint32, _tmp26_, _tmp26__size + 1);
		}
		_tmp26_[_tmp26__length++] = g_variant_get_uint32 (_tmp28_);
		g_variant_unref (_tmp28_);
	}
	_result_length1 = _tmp26__length1;
	_result = _tmp26_;
	g_variant_unref (_tmp25_);
	*result_length1 = _result_length1;
	g_object_unref (_reply_message);
	return _result;
}

static void
zeitgeist_remote_log_proxy_install_monitor_async (ZeitgeistRemoteLog* self,
                                                  const char* monitor_path,
                                                  GVariant* time_range,
                                                  GVariant* event_templates,
                                                  const char* owner,
                                                  GAsyncReadyCallback _callback_,
                                                  gpointer _user_data_)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.gnome.zeitgeist.Log", "InstallMonitor");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_object_path (monitor_path));
	g_variant_builder_add_value (&_arguments_builder, time_range);
	g_variant_builder_add_value (&_arguments_builder, event_templates);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	if (_callback_ != NULL) {
		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_task_new ((GObject *) self, NULL, _callback_, _user_data_));
	} else {
		g_dbus_message_set_flags (_message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
		g_dbus_connection_send_message (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	}
	g_object_unref (_message);
}

static void
zeitgeist_remote_log_proxy_install_monitor_finish (ZeitgeistRemoteLog* self,
                                                   GAsyncResult* _res_,
                                                   GError** error)
{
	GAsyncResult *_inner_res;
	GDBusMessage *_reply_message;
	_inner_res = g_task_propagate_pointer ((GTask *) _res_, NULL);
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), _inner_res, error);
	g_object_unref (_inner_res);
	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
zeitgeist_remote_log_proxy_remove_monitor_async (ZeitgeistRemoteLog* self,
                                                 const char* monitor_path,
                                                 const char* owner,
                                                 GAsyncReadyCallback _callback_,
                                                 gpointer _user_data_)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.gnome.zeitgeist.Log", "RemoveMonitor");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_object_path (monitor_path));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	if (_callback_ != NULL) {
		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_task_new ((GObject *) self, NULL, _callback_, _user_data_));
	} else {
		g_dbus_message_set_flags (_message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
		g_dbus_connection_send_message (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	}
	g_object_unref (_message);
}

static void
zeitgeist_remote_log_proxy_remove_monitor_finish (ZeitgeistRemoteLog* self,
                                                  GAsyncResult* _res_,
                                                  GError** error)
{
	GAsyncResult *_inner_res;
	GDBusMessage *_reply_message;
	_inner_res = g_task_propagate_pointer ((GTask *) _res_, NULL);
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), _inner_res, error);
	g_object_unref (_inner_res);
	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
zeitgeist_remote_log_proxy_quit_async (ZeitgeistRemoteLog* self,
                                       GCancellable* cancellable,
                                       GAsyncReadyCallback _callback_,
                                       gpointer _user_data_)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.gnome.zeitgeist.Log", "Quit");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	if (_callback_ != NULL) {
		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, cancellable, _vala_g_async_ready_callback, g_task_new ((GObject *) self, NULL, _callback_, _user_data_));
	} else {
		g_dbus_message_set_flags (_message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
		g_dbus_connection_send_message (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	}
	g_object_unref (_message);
}

static void
zeitgeist_remote_log_proxy_quit_finish (ZeitgeistRemoteLog* self,
                                        GAsyncResult* _res_,
                                        GError** error)
{
	GAsyncResult *_inner_res;
	GDBusMessage *_reply_message;
	_inner_res = g_task_propagate_pointer ((GTask *) _res_, NULL);
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), _inner_res, error);
	g_object_unref (_inner_res);
	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 gchar**
zeitgeist_remote_log_dbus_proxy_get_extensions (ZeitgeistRemoteLog* self,
                                                gint* result_length1)
{
	GVariant *_inner_reply;
	gchar** _result;
	gint _result_length1;
	gchar** _tmp29_;
	gint _tmp29__length;
	gint _tmp29__size;
	gint _tmp29__length1;
	GVariantIter _tmp30_;
	GVariant* _tmp31_;
	_inner_reply = g_dbus_proxy_get_cached_property ((GDBusProxy *) self, "extensions");
	if (!_inner_reply) {
		GVariant *_arguments;
		GVariant *_reply;
		GVariantBuilder _arguments_builder;
		g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
		g_variant_builder_add_value (&_arguments_builder, g_variant_new_string ("org.gnome.zeitgeist.Log"));
		g_variant_builder_add_value (&_arguments_builder, g_variant_new_string ("extensions"));
		_arguments = g_variant_builder_end (&_arguments_builder);
		_reply = g_dbus_proxy_call_sync ((GDBusProxy *) self, "org.freedesktop.DBus.Properties.Get", _arguments, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL);
		if (!_reply) {
			return NULL;
		}
		g_variant_get (_reply, "(v)", &_inner_reply);
		g_variant_unref (_reply);
	}
	_result_length1 = 0;
	_tmp29_ = g_new (gchar*, 5);
	_tmp29__length = 0;
	_tmp29__size = 4;
	_tmp29__length1 = 0;
	g_variant_iter_init (&_tmp30_, _inner_reply);
	for (; (_tmp31_ = g_variant_iter_next_value (&_tmp30_)) != NULL; _tmp29__length1++) {
		if (_tmp29__size == _tmp29__length) {
			_tmp29__size = 2 * _tmp29__size;
			_tmp29_ = g_renew (gchar*, _tmp29_, _tmp29__size + 1);
		}
		_tmp29_[_tmp29__length++] = g_variant_dup_string (_tmp31_, NULL);
		g_variant_unref (_tmp31_);
	}
	_result_length1 = _tmp29__length1;
	_tmp29_[_tmp29__length] = NULL;
	_result = _tmp29_;
	*result_length1 = _result_length1;
	g_variant_unref (_inner_reply);
	return _result;
}

static void
zeitgeist_remote_log_dbus_proxy_get_version (ZeitgeistRemoteLog* self,
                                             ZeitgeistVersionStruct* result)
{
	GVariant *_inner_reply;
	ZeitgeistVersionStruct _tmp32_;
	GVariantIter _tmp33_;
	GVariant* _tmp34_;
	GVariant* _tmp35_;
	GVariant* _tmp36_;
	_inner_reply = g_dbus_proxy_get_cached_property ((GDBusProxy *) self, "version");
	if (!_inner_reply) {
		GVariant *_arguments;
		GVariant *_reply;
		GVariantBuilder _arguments_builder;
		g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
		g_variant_builder_add_value (&_arguments_builder, g_variant_new_string ("org.gnome.zeitgeist.Log"));
		g_variant_builder_add_value (&_arguments_builder, g_variant_new_string ("version"));
		_arguments = g_variant_builder_end (&_arguments_builder);
		_reply = g_dbus_proxy_call_sync ((GDBusProxy *) self, "org.freedesktop.DBus.Properties.Get", _arguments, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL);
		if (!_reply) {
			return;
		}
		g_variant_get (_reply, "(v)", &_inner_reply);
		g_variant_unref (_reply);
	}
	g_variant_iter_init (&_tmp33_, _inner_reply);
	_tmp34_ = g_variant_iter_next_value (&_tmp33_);
	_tmp32_.major = g_variant_get_int32 (_tmp34_);
	g_variant_unref (_tmp34_);
	_tmp35_ = g_variant_iter_next_value (&_tmp33_);
	_tmp32_.minor = g_variant_get_int32 (_tmp35_);
	g_variant_unref (_tmp35_);
	_tmp36_ = g_variant_iter_next_value (&_tmp33_);
	_tmp32_.micro = g_variant_get_int32 (_tmp36_);
	g_variant_unref (_tmp36_);
	*result = _tmp32_;
	g_variant_unref (_inner_reply);
	return;
}

static gchar*
zeitgeist_remote_log_dbus_proxy_get_datapath (ZeitgeistRemoteLog* self)
{
	GVariant *_inner_reply;
	gchar* _result;
	_inner_reply = g_dbus_proxy_get_cached_property ((GDBusProxy *) self, "datapath");
	if (!_inner_reply) {
		GVariant *_arguments;
		GVariant *_reply;
		GVariantBuilder _arguments_builder;
		g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
		g_variant_builder_add_value (&_arguments_builder, g_variant_new_string ("org.gnome.zeitgeist.Log"));
		g_variant_builder_add_value (&_arguments_builder, g_variant_new_string ("datapath"));
		_arguments = g_variant_builder_end (&_arguments_builder);
		_reply = g_dbus_proxy_call_sync ((GDBusProxy *) self, "org.freedesktop.DBus.Properties.Get", _arguments, G_DBUS_CALL_FLAGS_NONE, -1, NULL, NULL);
		if (!_reply) {
			return NULL;
		}
		g_variant_get (_reply, "(v)", &_inner_reply);
		g_variant_unref (_reply);
	}
	_result = g_variant_dup_string (_inner_reply, NULL);
	g_variant_unref (_inner_reply);
	return _result;
}

static void
zeitgeist_remote_log_proxy_zeitgeist_remote_log_interface_init (ZeitgeistRemoteLogIface* iface)
{
	iface->delete_events = zeitgeist_remote_log_proxy_delete_events_async;
	iface->delete_events_finish = zeitgeist_remote_log_proxy_delete_events_finish;
	iface->find_event_ids = zeitgeist_remote_log_proxy_find_event_ids_async;
	iface->find_event_ids_finish = zeitgeist_remote_log_proxy_find_event_ids_finish;
	iface->find_events = zeitgeist_remote_log_proxy_find_events_async;
	iface->find_events_finish = zeitgeist_remote_log_proxy_find_events_finish;
	iface->find_related_uris = zeitgeist_remote_log_proxy_find_related_uris_async;
	iface->find_related_uris_finish = zeitgeist_remote_log_proxy_find_related_uris_finish;
	iface->get_events = zeitgeist_remote_log_proxy_get_events_async;
	iface->get_events_finish = zeitgeist_remote_log_proxy_get_events_finish;
	iface->insert_events = zeitgeist_remote_log_proxy_insert_events_async;
	iface->insert_events_finish = zeitgeist_remote_log_proxy_insert_events_finish;
	iface->install_monitor = zeitgeist_remote_log_proxy_install_monitor_async;
	iface->install_monitor_finish = zeitgeist_remote_log_proxy_install_monitor_finish;
	iface->remove_monitor = zeitgeist_remote_log_proxy_remove_monitor_async;
	iface->remove_monitor_finish = zeitgeist_remote_log_proxy_remove_monitor_finish;
	iface->quit = zeitgeist_remote_log_proxy_quit_async;
	iface->quit_finish = zeitgeist_remote_log_proxy_quit_finish;
	iface->get_extensions = zeitgeist_remote_log_dbus_proxy_get_extensions;
	iface->get_version = zeitgeist_remote_log_dbus_proxy_get_version;
	iface->get_datapath = zeitgeist_remote_log_dbus_proxy_get_datapath;
}

static void
_dbus_zeitgeist_remote_log_delete_events (ZeitgeistRemoteLog* self,
                                          GVariant* _parameters_,
                                          GDBusMethodInvocation* invocation)
{
	GVariantIter _arguments_iter;
	ZeitgeistRemoteLogDeleteEventsReadyData* _ready_data;
	GVariant* _tmp37_;
	guint32* _tmp38_;
	gint _tmp38__length;
	gint _tmp38__size;
	gint _tmp38__length1;
	GVariantIter _tmp39_;
	GVariant* _tmp40_;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_ready_data = g_slice_new0 (ZeitgeistRemoteLogDeleteEventsReadyData);
	_ready_data->_invocation_ = invocation;
	_tmp37_ = g_variant_iter_next_value (&_arguments_iter);
	_tmp38_ = g_new (guint32, 5);
	_tmp38__length = 0;
	_tmp38__size = 4;
	_tmp38__length1 = 0;
	g_variant_iter_init (&_tmp39_, _tmp37_);
	for (; (_tmp40_ = g_variant_iter_next_value (&_tmp39_)) != NULL; _tmp38__length1++) {
		if (_tmp38__size == _tmp38__length) {
			_tmp38__size = 2 * _tmp38__size;
			_tmp38_ = g_renew (guint32, _tmp38_, _tmp38__size + 1);
		}
		_tmp38_[_tmp38__length++] = g_variant_get_uint32 (_tmp40_);
		g_variant_unref (_tmp40_);
	}
	_ready_data->event_ids_length1 = _tmp38__length1;
	_ready_data->event_ids = _tmp38_;
	g_variant_unref (_tmp37_);
	zeitgeist_remote_log_delete_events (self, _ready_data->event_ids, _ready_data->event_ids_length1, NULL, g_dbus_method_invocation_get_sender (invocation), (GAsyncReadyCallback) _dbus_zeitgeist_remote_log_delete_events_ready, _ready_data);
	_error:
	;
}

static void
_dbus_zeitgeist_remote_log_delete_events_ready (GObject * source_object,
                                                GAsyncResult * _res_,
                                                gpointer _user_data_)
{
	ZeitgeistRemoteLogDeleteEventsReadyData* _ready_data;
	GDBusMethodInvocation* invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	GVariant* result;
	_ready_data = _user_data_;
	invocation = _ready_data->_invocation_;
	result = zeitgeist_remote_log_delete_events_finish ((ZeitgeistRemoteLog*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_take_error (invocation, error);
		goto _error;
	}
	_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, 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);
	_error:
	_ready_data->event_ids = (g_free (_ready_data->event_ids), NULL);
	g_slice_free (ZeitgeistRemoteLogDeleteEventsReadyData, _ready_data);
}

static void
_dbus_zeitgeist_remote_log_find_event_ids (ZeitgeistRemoteLog* self,
                                           GVariant* _parameters_,
                                           GDBusMethodInvocation* invocation)
{
	GVariantIter _arguments_iter;
	ZeitgeistRemoteLogFindEventIdsReadyData* _ready_data;
	GVariant* _tmp41_;
	GVariant* _tmp42_;
	GVariant* _tmp43_;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_ready_data = g_slice_new0 (ZeitgeistRemoteLogFindEventIdsReadyData);
	_ready_data->_invocation_ = invocation;
	_ready_data->time_range = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->event_templates = g_variant_iter_next_value (&_arguments_iter);
	_tmp41_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->storage_state = g_variant_get_uint32 (_tmp41_);
	g_variant_unref (_tmp41_);
	_tmp42_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->num_events = g_variant_get_uint32 (_tmp42_);
	g_variant_unref (_tmp42_);
	_tmp43_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->result_type = g_variant_get_uint32 (_tmp43_);
	g_variant_unref (_tmp43_);
	zeitgeist_remote_log_find_event_ids (self, _ready_data->time_range, _ready_data->event_templates, _ready_data->storage_state, _ready_data->num_events, _ready_data->result_type, NULL, g_dbus_method_invocation_get_sender (invocation), (GAsyncReadyCallback) _dbus_zeitgeist_remote_log_find_event_ids_ready, _ready_data);
	_error:
	;
}

static void
_dbus_zeitgeist_remote_log_find_event_ids_ready (GObject * source_object,
                                                 GAsyncResult * _res_,
                                                 gpointer _user_data_)
{
	ZeitgeistRemoteLogFindEventIdsReadyData* _ready_data;
	GDBusMethodInvocation* invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint32* result;
	gint result_length1 = 0;
	guint32* _tmp44_;
	GVariantBuilder _tmp45_;
	gint _tmp46_;
	_ready_data = _user_data_;
	invocation = _ready_data->_invocation_;
	result = zeitgeist_remote_log_find_event_ids_finish ((ZeitgeistRemoteLog*) source_object, _res_, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_take_error (invocation, error);
		goto _error;
	}
	_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);
	_tmp44_ = result;
	g_variant_builder_init (&_tmp45_, G_VARIANT_TYPE ("au"));
	for (_tmp46_ = 0; _tmp46_ < result_length1; _tmp46_++) {
		g_variant_builder_add_value (&_tmp45_, g_variant_new_uint32 (*_tmp44_));
		_tmp44_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp45_));
	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);
	_error:
	_g_variant_unref0 (_ready_data->time_range);
	_g_variant_unref0 (_ready_data->event_templates);
	g_slice_free (ZeitgeistRemoteLogFindEventIdsReadyData, _ready_data);
}

static void
_dbus_zeitgeist_remote_log_find_events (ZeitgeistRemoteLog* self,
                                        GVariant* _parameters_,
                                        GDBusMethodInvocation* invocation)
{
	GVariantIter _arguments_iter;
	ZeitgeistRemoteLogFindEventsReadyData* _ready_data;
	GVariant* _tmp47_;
	GVariant* _tmp48_;
	GVariant* _tmp49_;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_ready_data = g_slice_new0 (ZeitgeistRemoteLogFindEventsReadyData);
	_ready_data->_invocation_ = invocation;
	_ready_data->time_range = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->event_templates = g_variant_iter_next_value (&_arguments_iter);
	_tmp47_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->storage_state = g_variant_get_uint32 (_tmp47_);
	g_variant_unref (_tmp47_);
	_tmp48_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->num_events = g_variant_get_uint32 (_tmp48_);
	g_variant_unref (_tmp48_);
	_tmp49_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->result_type = g_variant_get_uint32 (_tmp49_);
	g_variant_unref (_tmp49_);
	zeitgeist_remote_log_find_events (self, _ready_data->time_range, _ready_data->event_templates, _ready_data->storage_state, _ready_data->num_events, _ready_data->result_type, NULL, g_dbus_method_invocation_get_sender (invocation), (GAsyncReadyCallback) _dbus_zeitgeist_remote_log_find_events_ready, _ready_data);
	_error:
	;
}

static void
_dbus_zeitgeist_remote_log_find_events_ready (GObject * source_object,
                                              GAsyncResult * _res_,
                                              gpointer _user_data_)
{
	ZeitgeistRemoteLogFindEventsReadyData* _ready_data;
	GDBusMethodInvocation* invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	GVariant* result;
	_ready_data = _user_data_;
	invocation = _ready_data->_invocation_;
	result = zeitgeist_remote_log_find_events_finish ((ZeitgeistRemoteLog*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_take_error (invocation, error);
		goto _error;
	}
	_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, 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);
	_error:
	_g_variant_unref0 (_ready_data->time_range);
	_g_variant_unref0 (_ready_data->event_templates);
	g_slice_free (ZeitgeistRemoteLogFindEventsReadyData, _ready_data);
}

static void
_dbus_zeitgeist_remote_log_find_related_uris (ZeitgeistRemoteLog* self,
                                              GVariant* _parameters_,
                                              GDBusMethodInvocation* invocation)
{
	GVariantIter _arguments_iter;
	ZeitgeistRemoteLogFindRelatedUrisReadyData* _ready_data;
	GVariant* _tmp50_;
	GVariant* _tmp51_;
	GVariant* _tmp52_;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_ready_data = g_slice_new0 (ZeitgeistRemoteLogFindRelatedUrisReadyData);
	_ready_data->_invocation_ = invocation;
	_ready_data->time_range = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->event_templates = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->result_event_templates = g_variant_iter_next_value (&_arguments_iter);
	_tmp50_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->storage_state = g_variant_get_uint32 (_tmp50_);
	g_variant_unref (_tmp50_);
	_tmp51_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->num_events = g_variant_get_uint32 (_tmp51_);
	g_variant_unref (_tmp51_);
	_tmp52_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->result_type = g_variant_get_uint32 (_tmp52_);
	g_variant_unref (_tmp52_);
	zeitgeist_remote_log_find_related_uris (self, _ready_data->time_range, _ready_data->event_templates, _ready_data->result_event_templates, _ready_data->storage_state, _ready_data->num_events, _ready_data->result_type, NULL, g_dbus_method_invocation_get_sender (invocation), (GAsyncReadyCallback) _dbus_zeitgeist_remote_log_find_related_uris_ready, _ready_data);
	_error:
	;
}

static void
_dbus_zeitgeist_remote_log_find_related_uris_ready (GObject * source_object,
                                                    GAsyncResult * _res_,
                                                    gpointer _user_data_)
{
	ZeitgeistRemoteLogFindRelatedUrisReadyData* _ready_data;
	GDBusMethodInvocation* invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar** result;
	gint result_length1 = 0;
	gchar** _tmp53_;
	GVariantBuilder _tmp54_;
	gint _tmp55_;
	_ready_data = _user_data_;
	invocation = _ready_data->_invocation_;
	result = zeitgeist_remote_log_find_related_uris_finish ((ZeitgeistRemoteLog*) source_object, _res_, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_take_error (invocation, error);
		goto _error;
	}
	_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);
	_tmp53_ = result;
	g_variant_builder_init (&_tmp54_, G_VARIANT_TYPE ("as"));
	for (_tmp55_ = 0; _tmp55_ < result_length1; _tmp55_++) {
		g_variant_builder_add_value (&_tmp54_, g_variant_new_string (*_tmp53_));
		_tmp53_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp54_));
	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);
	_error:
	_g_variant_unref0 (_ready_data->time_range);
	_g_variant_unref0 (_ready_data->event_templates);
	_g_variant_unref0 (_ready_data->result_event_templates);
	g_slice_free (ZeitgeistRemoteLogFindRelatedUrisReadyData, _ready_data);
}

static void
_dbus_zeitgeist_remote_log_get_events (ZeitgeistRemoteLog* self,
                                       GVariant* _parameters_,
                                       GDBusMethodInvocation* invocation)
{
	GVariantIter _arguments_iter;
	ZeitgeistRemoteLogGetEventsReadyData* _ready_data;
	GVariant* _tmp56_;
	guint32* _tmp57_;
	gint _tmp57__length;
	gint _tmp57__size;
	gint _tmp57__length1;
	GVariantIter _tmp58_;
	GVariant* _tmp59_;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_ready_data = g_slice_new0 (ZeitgeistRemoteLogGetEventsReadyData);
	_ready_data->_invocation_ = invocation;
	_tmp56_ = g_variant_iter_next_value (&_arguments_iter);
	_tmp57_ = g_new (guint32, 5);
	_tmp57__length = 0;
	_tmp57__size = 4;
	_tmp57__length1 = 0;
	g_variant_iter_init (&_tmp58_, _tmp56_);
	for (; (_tmp59_ = g_variant_iter_next_value (&_tmp58_)) != NULL; _tmp57__length1++) {
		if (_tmp57__size == _tmp57__length) {
			_tmp57__size = 2 * _tmp57__size;
			_tmp57_ = g_renew (guint32, _tmp57_, _tmp57__size + 1);
		}
		_tmp57_[_tmp57__length++] = g_variant_get_uint32 (_tmp59_);
		g_variant_unref (_tmp59_);
	}
	_ready_data->event_ids_length1 = _tmp57__length1;
	_ready_data->event_ids = _tmp57_;
	g_variant_unref (_tmp56_);
	zeitgeist_remote_log_get_events (self, _ready_data->event_ids, _ready_data->event_ids_length1, NULL, g_dbus_method_invocation_get_sender (invocation), (GAsyncReadyCallback) _dbus_zeitgeist_remote_log_get_events_ready, _ready_data);
	_error:
	;
}

static void
_dbus_zeitgeist_remote_log_get_events_ready (GObject * source_object,
                                             GAsyncResult * _res_,
                                             gpointer _user_data_)
{
	ZeitgeistRemoteLogGetEventsReadyData* _ready_data;
	GDBusMethodInvocation* invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	GVariant* result;
	_ready_data = _user_data_;
	invocation = _ready_data->_invocation_;
	result = zeitgeist_remote_log_get_events_finish ((ZeitgeistRemoteLog*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_take_error (invocation, error);
		goto _error;
	}
	_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, 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);
	_error:
	_ready_data->event_ids = (g_free (_ready_data->event_ids), NULL);
	g_slice_free (ZeitgeistRemoteLogGetEventsReadyData, _ready_data);
}

static void
_dbus_zeitgeist_remote_log_insert_events (ZeitgeistRemoteLog* self,
                                          GVariant* _parameters_,
                                          GDBusMethodInvocation* invocation)
{
	GVariantIter _arguments_iter;
	ZeitgeistRemoteLogInsertEventsReadyData* _ready_data;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_ready_data = g_slice_new0 (ZeitgeistRemoteLogInsertEventsReadyData);
	_ready_data->_invocation_ = invocation;
	_ready_data->events = g_variant_iter_next_value (&_arguments_iter);
	zeitgeist_remote_log_insert_events (self, _ready_data->events, NULL, g_dbus_method_invocation_get_sender (invocation), (GAsyncReadyCallback) _dbus_zeitgeist_remote_log_insert_events_ready, _ready_data);
	_error:
	;
}

static void
_dbus_zeitgeist_remote_log_insert_events_ready (GObject * source_object,
                                                GAsyncResult * _res_,
                                                gpointer _user_data_)
{
	ZeitgeistRemoteLogInsertEventsReadyData* _ready_data;
	GDBusMethodInvocation* invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint32* result;
	gint result_length1 = 0;
	guint32* _tmp60_;
	GVariantBuilder _tmp61_;
	gint _tmp62_;
	_ready_data = _user_data_;
	invocation = _ready_data->_invocation_;
	result = zeitgeist_remote_log_insert_events_finish ((ZeitgeistRemoteLog*) source_object, _res_, &result_length1, &error);
	if (error) {
		g_dbus_method_invocation_take_error (invocation, error);
		goto _error;
	}
	_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);
	_tmp60_ = result;
	g_variant_builder_init (&_tmp61_, G_VARIANT_TYPE ("au"));
	for (_tmp62_ = 0; _tmp62_ < result_length1; _tmp62_++) {
		g_variant_builder_add_value (&_tmp61_, g_variant_new_uint32 (*_tmp60_));
		_tmp60_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp61_));
	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);
	_error:
	_g_variant_unref0 (_ready_data->events);
	g_slice_free (ZeitgeistRemoteLogInsertEventsReadyData, _ready_data);
}

static void
_dbus_zeitgeist_remote_log_install_monitor (ZeitgeistRemoteLog* self,
                                            GVariant* _parameters_,
                                            GDBusMethodInvocation* invocation)
{
	GVariantIter _arguments_iter;
	ZeitgeistRemoteLogInstallMonitorReadyData* _ready_data;
	GVariant* _tmp63_;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_ready_data = g_slice_new0 (ZeitgeistRemoteLogInstallMonitorReadyData);
	_ready_data->_invocation_ = invocation;
	_tmp63_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->monitor_path = g_variant_dup_string (_tmp63_, NULL);
	g_variant_unref (_tmp63_);
	_ready_data->time_range = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->event_templates = g_variant_iter_next_value (&_arguments_iter);
	zeitgeist_remote_log_install_monitor (self, _ready_data->monitor_path, _ready_data->time_range, _ready_data->event_templates, g_dbus_method_invocation_get_sender (invocation), (GAsyncReadyCallback) _dbus_zeitgeist_remote_log_install_monitor_ready, _ready_data);
	_error:
	;
}

static void
_dbus_zeitgeist_remote_log_install_monitor_ready (GObject * source_object,
                                                  GAsyncResult * _res_,
                                                  gpointer _user_data_)
{
	ZeitgeistRemoteLogInstallMonitorReadyData* _ready_data;
	GDBusMethodInvocation* invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	_ready_data = _user_data_;
	invocation = _ready_data->_invocation_;
	zeitgeist_remote_log_install_monitor_finish ((ZeitgeistRemoteLog*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_take_error (invocation, error);
		goto _error;
	}
	_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);
	_error:
	_g_free0 (_ready_data->monitor_path);
	_g_variant_unref0 (_ready_data->time_range);
	_g_variant_unref0 (_ready_data->event_templates);
	g_slice_free (ZeitgeistRemoteLogInstallMonitorReadyData, _ready_data);
}

static void
_dbus_zeitgeist_remote_log_remove_monitor (ZeitgeistRemoteLog* self,
                                           GVariant* _parameters_,
                                           GDBusMethodInvocation* invocation)
{
	GVariantIter _arguments_iter;
	ZeitgeistRemoteLogRemoveMonitorReadyData* _ready_data;
	GVariant* _tmp64_;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_ready_data = g_slice_new0 (ZeitgeistRemoteLogRemoveMonitorReadyData);
	_ready_data->_invocation_ = invocation;
	_tmp64_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->monitor_path = g_variant_dup_string (_tmp64_, NULL);
	g_variant_unref (_tmp64_);
	zeitgeist_remote_log_remove_monitor (self, _ready_data->monitor_path, g_dbus_method_invocation_get_sender (invocation), (GAsyncReadyCallback) _dbus_zeitgeist_remote_log_remove_monitor_ready, _ready_data);
	_error:
	;
}

static void
_dbus_zeitgeist_remote_log_remove_monitor_ready (GObject * source_object,
                                                 GAsyncResult * _res_,
                                                 gpointer _user_data_)
{
	ZeitgeistRemoteLogRemoveMonitorReadyData* _ready_data;
	GDBusMethodInvocation* invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	_ready_data = _user_data_;
	invocation = _ready_data->_invocation_;
	zeitgeist_remote_log_remove_monitor_finish ((ZeitgeistRemoteLog*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_take_error (invocation, error);
		goto _error;
	}
	_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);
	_error:
	_g_free0 (_ready_data->monitor_path);
	g_slice_free (ZeitgeistRemoteLogRemoveMonitorReadyData, _ready_data);
}

static void
_dbus_zeitgeist_remote_log_quit (ZeitgeistRemoteLog* self,
                                 GVariant* _parameters_,
                                 GDBusMethodInvocation* invocation)
{
	GVariantIter _arguments_iter;
	ZeitgeistRemoteLogQuitReadyData* _ready_data;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_ready_data = g_slice_new0 (ZeitgeistRemoteLogQuitReadyData);
	_ready_data->_invocation_ = invocation;
	zeitgeist_remote_log_quit (self, NULL, (GAsyncReadyCallback) _dbus_zeitgeist_remote_log_quit_ready, _ready_data);
}

static void
_dbus_zeitgeist_remote_log_quit_ready (GObject * source_object,
                                       GAsyncResult * _res_,
                                       gpointer _user_data_)
{
	ZeitgeistRemoteLogQuitReadyData* _ready_data;
	GDBusMethodInvocation* invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	_ready_data = _user_data_;
	invocation = _ready_data->_invocation_;
	zeitgeist_remote_log_quit_finish ((ZeitgeistRemoteLog*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_take_error (invocation, error);
		goto _error;
	}
	_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);
	_error:
	g_slice_free (ZeitgeistRemoteLogQuitReadyData, _ready_data);
}

static void
zeitgeist_remote_log_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, "DeleteEvents") == 0) {
		_dbus_zeitgeist_remote_log_delete_events (object, parameters, invocation);
	} else if (strcmp (method_name, "FindEventIds") == 0) {
		_dbus_zeitgeist_remote_log_find_event_ids (object, parameters, invocation);
	} else if (strcmp (method_name, "FindEvents") == 0) {
		_dbus_zeitgeist_remote_log_find_events (object, parameters, invocation);
	} else if (strcmp (method_name, "FindRelatedUris") == 0) {
		_dbus_zeitgeist_remote_log_find_related_uris (object, parameters, invocation);
	} else if (strcmp (method_name, "GetEvents") == 0) {
		_dbus_zeitgeist_remote_log_get_events (object, parameters, invocation);
	} else if (strcmp (method_name, "InsertEvents") == 0) {
		_dbus_zeitgeist_remote_log_insert_events (object, parameters, invocation);
	} else if (strcmp (method_name, "InstallMonitor") == 0) {
		_dbus_zeitgeist_remote_log_install_monitor (object, parameters, invocation);
	} else if (strcmp (method_name, "RemoveMonitor") == 0) {
		_dbus_zeitgeist_remote_log_remove_monitor (object, parameters, invocation);
	} else if (strcmp (method_name, "Quit") == 0) {
		_dbus_zeitgeist_remote_log_quit (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}

static GVariant*
_dbus_zeitgeist_remote_log_get_extensions (ZeitgeistRemoteLog* self)
{
	gchar** result;
	gint result_length1 = 0;
	GVariant* _reply;
	gchar** _tmp65_;
	GVariantBuilder _tmp66_;
	gint _tmp67_;
	result = zeitgeist_remote_log_get_extensions (self, &result_length1);
	_tmp65_ = result;
	g_variant_builder_init (&_tmp66_, G_VARIANT_TYPE ("as"));
	for (_tmp67_ = 0; _tmp67_ < result_length1; _tmp67_++) {
		g_variant_builder_add_value (&_tmp66_, g_variant_new_string (*_tmp65_));
		_tmp65_++;
	}
	_reply = g_variant_builder_end (&_tmp66_);
	result = (_vala_array_free (result, result_length1, (GDestroyNotify) g_free), NULL);
	return _reply;
}

static GVariant*
_dbus_zeitgeist_remote_log_get_version (ZeitgeistRemoteLog* self)
{
	ZeitgeistVersionStruct result = {0};
	GVariant* _reply;
	GVariantBuilder _tmp68_;
	zeitgeist_remote_log_get_version (self, &result);
	g_variant_builder_init (&_tmp68_, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_tmp68_, g_variant_new_int32 (result.major));
	g_variant_builder_add_value (&_tmp68_, g_variant_new_int32 (result.minor));
	g_variant_builder_add_value (&_tmp68_, g_variant_new_int32 (result.micro));
	_reply = g_variant_builder_end (&_tmp68_);
	return _reply;
}

static GVariant*
_dbus_zeitgeist_remote_log_get_datapath (ZeitgeistRemoteLog* self)
{
	gchar* result;
	GVariant* _reply;
	result = zeitgeist_remote_log_get_datapath (self);
	_reply = g_variant_new_string (result);
	_g_free0 (result);
	return _reply;
}

static GVariant*
zeitgeist_remote_log_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];
	if (strcmp (property_name, "extensions") == 0) {
		return _dbus_zeitgeist_remote_log_get_extensions (object);
	} else if (strcmp (property_name, "version") == 0) {
		return _dbus_zeitgeist_remote_log_get_version (object);
	} else if (strcmp (property_name, "datapath") == 0) {
		return _dbus_zeitgeist_remote_log_get_datapath (object);
	}
	return NULL;
}

static gboolean
zeitgeist_remote_log_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)
{
	return FALSE;
}

guint
zeitgeist_remote_log_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 *) (&_zeitgeist_remote_log_dbus_interface_info), &_zeitgeist_remote_log_dbus_interface_vtable, data, _zeitgeist_remote_log_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}

static void
_zeitgeist_remote_log_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
zeitgeist_remote_monitor_notify_insert (ZeitgeistRemoteMonitor* self,
                                        GVariant* time_range,
                                        GVariant* events,
                                        GAsyncReadyCallback _callback_,
                                        gpointer _user_data_)
{
	ZeitgeistRemoteMonitorIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_MONITOR_GET_INTERFACE (self);
	if (_iface_->notify_insert) {
		_iface_->notify_insert (self, time_range, events, _callback_, _user_data_);
	}
}

void
zeitgeist_remote_monitor_notify_insert_finish (ZeitgeistRemoteMonitor* self,
                                               GAsyncResult* _res_,
                                               GError** error)
{
	ZeitgeistRemoteMonitorIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_MONITOR_GET_INTERFACE (self);
	if (_iface_->notify_insert_finish) {
		_iface_->notify_insert_finish (self, _res_, error);
	}
}

void
zeitgeist_remote_monitor_notify_delete (ZeitgeistRemoteMonitor* self,
                                        GVariant* time_range,
                                        guint32* event_ids,
                                        gint event_ids_length1,
                                        GAsyncReadyCallback _callback_,
                                        gpointer _user_data_)
{
	ZeitgeistRemoteMonitorIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_MONITOR_GET_INTERFACE (self);
	if (_iface_->notify_delete) {
		_iface_->notify_delete (self, time_range, event_ids, event_ids_length1, _callback_, _user_data_);
	}
}

void
zeitgeist_remote_monitor_notify_delete_finish (ZeitgeistRemoteMonitor* self,
                                               GAsyncResult* _res_,
                                               GError** error)
{
	ZeitgeistRemoteMonitorIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_MONITOR_GET_INTERFACE (self);
	if (_iface_->notify_delete_finish) {
		_iface_->notify_delete_finish (self, _res_, error);
	}
}

static void
zeitgeist_remote_monitor_default_init (ZeitgeistRemoteMonitorIface * iface,
                                       gpointer iface_data)
{
}

static GType
zeitgeist_remote_monitor_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ZeitgeistRemoteMonitorIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) zeitgeist_remote_monitor_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
	GType zeitgeist_remote_monitor_type_id;
	zeitgeist_remote_monitor_type_id = g_type_register_static (G_TYPE_INTERFACE, "ZeitgeistRemoteMonitor", &g_define_type_info, 0);
	g_type_interface_add_prerequisite (zeitgeist_remote_monitor_type_id, G_TYPE_OBJECT);
	g_type_set_qdata (zeitgeist_remote_monitor_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) zeitgeist_remote_monitor_proxy_get_type);
	g_type_set_qdata (zeitgeist_remote_monitor_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.gnome.zeitgeist.Monitor");
	g_type_set_qdata (zeitgeist_remote_monitor_type_id, g_quark_from_static_string ("vala-dbus-interface-info"), (void*) (&_zeitgeist_remote_monitor_dbus_interface_info));
	g_type_set_qdata (zeitgeist_remote_monitor_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) zeitgeist_remote_monitor_register_object);
	return zeitgeist_remote_monitor_type_id;
}

GType
zeitgeist_remote_monitor_get_type (void)
{
	static volatile gsize zeitgeist_remote_monitor_type_id__once = 0;
	if (g_once_init_enter (&zeitgeist_remote_monitor_type_id__once)) {
		GType zeitgeist_remote_monitor_type_id;
		zeitgeist_remote_monitor_type_id = zeitgeist_remote_monitor_get_type_once ();
		g_once_init_leave (&zeitgeist_remote_monitor_type_id__once, zeitgeist_remote_monitor_type_id);
	}
	return zeitgeist_remote_monitor_type_id__once;
}

G_DEFINE_TYPE_EXTENDED (ZeitgeistRemoteMonitorProxy, zeitgeist_remote_monitor_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (ZEITGEIST_TYPE_REMOTE_MONITOR, zeitgeist_remote_monitor_proxy_zeitgeist_remote_monitor_interface_init) )
static void
zeitgeist_remote_monitor_proxy_class_init (ZeitgeistRemoteMonitorProxyClass* klass)
{
	G_DBUS_PROXY_CLASS (klass)->g_signal = zeitgeist_remote_monitor_proxy_g_signal;
}

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

static void
zeitgeist_remote_monitor_proxy_init (ZeitgeistRemoteMonitorProxy* self)
{
	g_dbus_proxy_set_interface_info (G_DBUS_PROXY (self), (GDBusInterfaceInfo *) (&_zeitgeist_remote_monitor_dbus_interface_info));
}

static void
zeitgeist_remote_monitor_proxy_notify_insert_async (ZeitgeistRemoteMonitor* self,
                                                    GVariant* time_range,
                                                    GVariant* events,
                                                    GAsyncReadyCallback _callback_,
                                                    gpointer _user_data_)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.gnome.zeitgeist.Monitor", "NotifyInsert");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, time_range);
	g_variant_builder_add_value (&_arguments_builder, events);
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	if (_callback_ != NULL) {
		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_task_new ((GObject *) self, NULL, _callback_, _user_data_));
	} else {
		g_dbus_message_set_flags (_message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
		g_dbus_connection_send_message (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	}
	g_object_unref (_message);
}

static void
zeitgeist_remote_monitor_proxy_notify_insert_finish (ZeitgeistRemoteMonitor* self,
                                                     GAsyncResult* _res_,
                                                     GError** error)
{
	GAsyncResult *_inner_res;
	GDBusMessage *_reply_message;
	_inner_res = g_task_propagate_pointer ((GTask *) _res_, NULL);
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), _inner_res, error);
	g_object_unref (_inner_res);
	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
zeitgeist_remote_monitor_proxy_notify_delete_async (ZeitgeistRemoteMonitor* self,
                                                    GVariant* time_range,
                                                    guint32* event_ids,
                                                    gint event_ids_length1,
                                                    GAsyncReadyCallback _callback_,
                                                    gpointer _user_data_)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	guint32* _tmp69_;
	GVariantBuilder _tmp70_;
	gint _tmp71_;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.gnome.zeitgeist.Monitor", "NotifyDelete");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, time_range);
	_tmp69_ = event_ids;
	g_variant_builder_init (&_tmp70_, G_VARIANT_TYPE ("au"));
	for (_tmp71_ = 0; _tmp71_ < event_ids_length1; _tmp71_++) {
		g_variant_builder_add_value (&_tmp70_, g_variant_new_uint32 (*_tmp69_));
		_tmp69_++;
	}
	g_variant_builder_add_value (&_arguments_builder, g_variant_builder_end (&_tmp70_));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	if (_callback_ != NULL) {
		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_task_new ((GObject *) self, NULL, _callback_, _user_data_));
	} else {
		g_dbus_message_set_flags (_message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
		g_dbus_connection_send_message (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	}
	g_object_unref (_message);
}

static void
zeitgeist_remote_monitor_proxy_notify_delete_finish (ZeitgeistRemoteMonitor* self,
                                                     GAsyncResult* _res_,
                                                     GError** error)
{
	GAsyncResult *_inner_res;
	GDBusMessage *_reply_message;
	_inner_res = g_task_propagate_pointer ((GTask *) _res_, NULL);
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), _inner_res, error);
	g_object_unref (_inner_res);
	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
zeitgeist_remote_monitor_proxy_zeitgeist_remote_monitor_interface_init (ZeitgeistRemoteMonitorIface* iface)
{
	iface->notify_insert = zeitgeist_remote_monitor_proxy_notify_insert_async;
	iface->notify_insert_finish = zeitgeist_remote_monitor_proxy_notify_insert_finish;
	iface->notify_delete = zeitgeist_remote_monitor_proxy_notify_delete_async;
	iface->notify_delete_finish = zeitgeist_remote_monitor_proxy_notify_delete_finish;
}

static void
_dbus_zeitgeist_remote_monitor_notify_insert (ZeitgeistRemoteMonitor* self,
                                              GVariant* _parameters_,
                                              GDBusMethodInvocation* invocation)
{
	GVariantIter _arguments_iter;
	ZeitgeistRemoteMonitorNotifyInsertReadyData* _ready_data;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_ready_data = g_slice_new0 (ZeitgeistRemoteMonitorNotifyInsertReadyData);
	_ready_data->_invocation_ = invocation;
	_ready_data->time_range = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->events = g_variant_iter_next_value (&_arguments_iter);
	zeitgeist_remote_monitor_notify_insert (self, _ready_data->time_range, _ready_data->events, (GAsyncReadyCallback) _dbus_zeitgeist_remote_monitor_notify_insert_ready, _ready_data);
	_error:
	;
}

static void
_dbus_zeitgeist_remote_monitor_notify_insert_ready (GObject * source_object,
                                                    GAsyncResult * _res_,
                                                    gpointer _user_data_)
{
	ZeitgeistRemoteMonitorNotifyInsertReadyData* _ready_data;
	GDBusMethodInvocation* invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	_ready_data = _user_data_;
	invocation = _ready_data->_invocation_;
	zeitgeist_remote_monitor_notify_insert_finish ((ZeitgeistRemoteMonitor*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_take_error (invocation, error);
		goto _error;
	}
	_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);
	_error:
	_g_variant_unref0 (_ready_data->time_range);
	_g_variant_unref0 (_ready_data->events);
	g_slice_free (ZeitgeistRemoteMonitorNotifyInsertReadyData, _ready_data);
}

static void
_dbus_zeitgeist_remote_monitor_notify_delete (ZeitgeistRemoteMonitor* self,
                                              GVariant* _parameters_,
                                              GDBusMethodInvocation* invocation)
{
	GVariantIter _arguments_iter;
	ZeitgeistRemoteMonitorNotifyDeleteReadyData* _ready_data;
	GVariant* _tmp72_;
	guint32* _tmp73_;
	gint _tmp73__length;
	gint _tmp73__size;
	gint _tmp73__length1;
	GVariantIter _tmp74_;
	GVariant* _tmp75_;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_ready_data = g_slice_new0 (ZeitgeistRemoteMonitorNotifyDeleteReadyData);
	_ready_data->_invocation_ = invocation;
	_ready_data->time_range = g_variant_iter_next_value (&_arguments_iter);
	_tmp72_ = g_variant_iter_next_value (&_arguments_iter);
	_tmp73_ = g_new (guint32, 5);
	_tmp73__length = 0;
	_tmp73__size = 4;
	_tmp73__length1 = 0;
	g_variant_iter_init (&_tmp74_, _tmp72_);
	for (; (_tmp75_ = g_variant_iter_next_value (&_tmp74_)) != NULL; _tmp73__length1++) {
		if (_tmp73__size == _tmp73__length) {
			_tmp73__size = 2 * _tmp73__size;
			_tmp73_ = g_renew (guint32, _tmp73_, _tmp73__size + 1);
		}
		_tmp73_[_tmp73__length++] = g_variant_get_uint32 (_tmp75_);
		g_variant_unref (_tmp75_);
	}
	_ready_data->event_ids_length1 = _tmp73__length1;
	_ready_data->event_ids = _tmp73_;
	g_variant_unref (_tmp72_);
	zeitgeist_remote_monitor_notify_delete (self, _ready_data->time_range, _ready_data->event_ids, _ready_data->event_ids_length1, (GAsyncReadyCallback) _dbus_zeitgeist_remote_monitor_notify_delete_ready, _ready_data);
	_error:
	;
}

static void
_dbus_zeitgeist_remote_monitor_notify_delete_ready (GObject * source_object,
                                                    GAsyncResult * _res_,
                                                    gpointer _user_data_)
{
	ZeitgeistRemoteMonitorNotifyDeleteReadyData* _ready_data;
	GDBusMethodInvocation* invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	_ready_data = _user_data_;
	invocation = _ready_data->_invocation_;
	zeitgeist_remote_monitor_notify_delete_finish ((ZeitgeistRemoteMonitor*) source_object, _res_, &error);
	if (error) {
		g_dbus_method_invocation_take_error (invocation, error);
		goto _error;
	}
	_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);
	_error:
	_g_variant_unref0 (_ready_data->time_range);
	_ready_data->event_ids = (g_free (_ready_data->event_ids), NULL);
	g_slice_free (ZeitgeistRemoteMonitorNotifyDeleteReadyData, _ready_data);
}

static void
zeitgeist_remote_monitor_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, "NotifyInsert") == 0) {
		_dbus_zeitgeist_remote_monitor_notify_insert (object, parameters, invocation);
	} else if (strcmp (method_name, "NotifyDelete") == 0) {
		_dbus_zeitgeist_remote_monitor_notify_delete (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}

static GVariant*
zeitgeist_remote_monitor_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)
{
	return NULL;
}

static gboolean
zeitgeist_remote_monitor_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)
{
	return FALSE;
}

guint
zeitgeist_remote_monitor_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 *) (&_zeitgeist_remote_monitor_dbus_interface_info), &_zeitgeist_remote_monitor_dbus_interface_vtable, data, _zeitgeist_remote_monitor_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}

static void
_zeitgeist_remote_monitor_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
zeitgeist_remote_simple_indexer_search (ZeitgeistRemoteSimpleIndexer* self,
                                        const gchar* query_string,
                                        GVariant* time_range,
                                        GVariant* filter_templates,
                                        guint offset,
                                        guint count,
                                        guint result_type,
                                        GCancellable* cancellable,
                                        GAsyncReadyCallback _callback_,
                                        gpointer _user_data_)
{
	ZeitgeistRemoteSimpleIndexerIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_SIMPLE_INDEXER_GET_INTERFACE (self);
	if (_iface_->search) {
		_iface_->search (self, query_string, time_range, filter_templates, offset, count, result_type, cancellable, _callback_, _user_data_);
	}
}

void
zeitgeist_remote_simple_indexer_search_finish (ZeitgeistRemoteSimpleIndexer* self,
                                               GAsyncResult* _res_,
                                               GVariant** events,
                                               guint* matches,
                                               GError** error)
{
	ZeitgeistRemoteSimpleIndexerIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_SIMPLE_INDEXER_GET_INTERFACE (self);
	if (_iface_->search_finish) {
		_iface_->search_finish (self, _res_, events, matches, error);
	}
}

void
zeitgeist_remote_simple_indexer_search_with_relevancies (ZeitgeistRemoteSimpleIndexer* self,
                                                         const gchar* query_string,
                                                         GVariant* time_range,
                                                         GVariant* filter_templates,
                                                         guint storage_state,
                                                         guint offset,
                                                         guint count,
                                                         guint result_type,
                                                         GCancellable* cancellable,
                                                         GAsyncReadyCallback _callback_,
                                                         gpointer _user_data_)
{
	ZeitgeistRemoteSimpleIndexerIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_SIMPLE_INDEXER_GET_INTERFACE (self);
	if (_iface_->search_with_relevancies) {
		_iface_->search_with_relevancies (self, query_string, time_range, filter_templates, storage_state, offset, count, result_type, cancellable, _callback_, _user_data_);
	}
}

void
zeitgeist_remote_simple_indexer_search_with_relevancies_finish (ZeitgeistRemoteSimpleIndexer* self,
                                                                GAsyncResult* _res_,
                                                                GVariant** events,
                                                                gdouble** relevancies,
                                                                gint* relevancies_length1,
                                                                guint* matches,
                                                                GError** error)
{
	ZeitgeistRemoteSimpleIndexerIface* _iface_;
	_iface_ = ZEITGEIST_REMOTE_SIMPLE_INDEXER_GET_INTERFACE (self);
	if (_iface_->search_with_relevancies_finish) {
		_iface_->search_with_relevancies_finish (self, _res_, events, relevancies, relevancies_length1, matches, error);
	}
}

static void
zeitgeist_remote_simple_indexer_default_init (ZeitgeistRemoteSimpleIndexerIface * iface,
                                              gpointer iface_data)
{
}

static GType
zeitgeist_remote_simple_indexer_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ZeitgeistRemoteSimpleIndexerIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) zeitgeist_remote_simple_indexer_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
	GType zeitgeist_remote_simple_indexer_type_id;
	zeitgeist_remote_simple_indexer_type_id = g_type_register_static (G_TYPE_INTERFACE, "ZeitgeistRemoteSimpleIndexer", &g_define_type_info, 0);
	g_type_interface_add_prerequisite (zeitgeist_remote_simple_indexer_type_id, G_TYPE_OBJECT);
	g_type_set_qdata (zeitgeist_remote_simple_indexer_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) zeitgeist_remote_simple_indexer_proxy_get_type);
	g_type_set_qdata (zeitgeist_remote_simple_indexer_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.gnome.zeitgeist.Index");
	g_type_set_qdata (zeitgeist_remote_simple_indexer_type_id, g_quark_from_static_string ("vala-dbus-interface-info"), (void*) (&_zeitgeist_remote_simple_indexer_dbus_interface_info));
	g_type_set_qdata (zeitgeist_remote_simple_indexer_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) zeitgeist_remote_simple_indexer_register_object);
	return zeitgeist_remote_simple_indexer_type_id;
}

GType
zeitgeist_remote_simple_indexer_get_type (void)
{
	static volatile gsize zeitgeist_remote_simple_indexer_type_id__once = 0;
	if (g_once_init_enter (&zeitgeist_remote_simple_indexer_type_id__once)) {
		GType zeitgeist_remote_simple_indexer_type_id;
		zeitgeist_remote_simple_indexer_type_id = zeitgeist_remote_simple_indexer_get_type_once ();
		g_once_init_leave (&zeitgeist_remote_simple_indexer_type_id__once, zeitgeist_remote_simple_indexer_type_id);
	}
	return zeitgeist_remote_simple_indexer_type_id__once;
}

G_DEFINE_TYPE_EXTENDED (ZeitgeistRemoteSimpleIndexerProxy, zeitgeist_remote_simple_indexer_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (ZEITGEIST_TYPE_REMOTE_SIMPLE_INDEXER, zeitgeist_remote_simple_indexer_proxy_zeitgeist_remote_simple_indexer_interface_init) )
static void
zeitgeist_remote_simple_indexer_proxy_class_init (ZeitgeistRemoteSimpleIndexerProxyClass* klass)
{
	G_DBUS_PROXY_CLASS (klass)->g_signal = zeitgeist_remote_simple_indexer_proxy_g_signal;
}

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

static void
zeitgeist_remote_simple_indexer_proxy_init (ZeitgeistRemoteSimpleIndexerProxy* self)
{
	g_dbus_proxy_set_interface_info (G_DBUS_PROXY (self), (GDBusInterfaceInfo *) (&_zeitgeist_remote_simple_indexer_dbus_interface_info));
}

static void
zeitgeist_remote_simple_indexer_proxy_search_async (ZeitgeistRemoteSimpleIndexer* self,
                                                    const gchar* query_string,
                                                    GVariant* time_range,
                                                    GVariant* filter_templates,
                                                    guint offset,
                                                    guint count,
                                                    guint result_type,
                                                    GCancellable* cancellable,
                                                    GAsyncReadyCallback _callback_,
                                                    gpointer _user_data_)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.gnome.zeitgeist.Index", "Search");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (query_string));
	g_variant_builder_add_value (&_arguments_builder, time_range);
	g_variant_builder_add_value (&_arguments_builder, filter_templates);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (offset));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (count));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (result_type));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	if (_callback_ != NULL) {
		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, cancellable, _vala_g_async_ready_callback, g_task_new ((GObject *) self, NULL, _callback_, _user_data_));
	} else {
		g_dbus_message_set_flags (_message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
		g_dbus_connection_send_message (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	}
	g_object_unref (_message);
}

static void
zeitgeist_remote_simple_indexer_proxy_search_finish (ZeitgeistRemoteSimpleIndexer* self,
                                                     GAsyncResult* _res_,
                                                     GVariant** events,
                                                     guint* matches,
                                                     GError** error)
{
	GAsyncResult *_inner_res;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	GVariant* _vala_events = NULL;
	guint _vala_matches = 0U;
	GVariant* _tmp76_;
	_inner_res = g_task_propagate_pointer ((GTask *) _res_, NULL);
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), _inner_res, error);
	g_object_unref (_inner_res);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_vala_events = g_variant_iter_next_value (&_reply_iter);
	*events = _vala_events;
	_tmp76_ = g_variant_iter_next_value (&_reply_iter);
	_vala_matches = g_variant_get_uint32 (_tmp76_);
	g_variant_unref (_tmp76_);
	*matches = _vala_matches;
	g_object_unref (_reply_message);
}

static void
zeitgeist_remote_simple_indexer_proxy_search_with_relevancies_async (ZeitgeistRemoteSimpleIndexer* self,
                                                                     const gchar* query_string,
                                                                     GVariant* time_range,
                                                                     GVariant* filter_templates,
                                                                     guint storage_state,
                                                                     guint offset,
                                                                     guint count,
                                                                     guint result_type,
                                                                     GCancellable* cancellable,
                                                                     GAsyncReadyCallback _callback_,
                                                                     gpointer _user_data_)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.gnome.zeitgeist.Index", "SearchWithRelevancies");
	g_variant_builder_init (&_arguments_builder, G_VARIANT_TYPE_TUPLE);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_string (query_string));
	g_variant_builder_add_value (&_arguments_builder, time_range);
	g_variant_builder_add_value (&_arguments_builder, filter_templates);
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (storage_state));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (offset));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (count));
	g_variant_builder_add_value (&_arguments_builder, g_variant_new_uint32 (result_type));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_message_set_body (_message, _arguments);
	if (_callback_ != NULL) {
		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, cancellable, _vala_g_async_ready_callback, g_task_new ((GObject *) self, NULL, _callback_, _user_data_));
	} else {
		g_dbus_message_set_flags (_message, G_DBUS_MESSAGE_FLAGS_NO_REPLY_EXPECTED);
		g_dbus_connection_send_message (g_dbus_proxy_get_connection ((GDBusProxy *) self), _message, G_DBUS_SEND_MESSAGE_FLAGS_NONE, NULL, NULL);
	}
	g_object_unref (_message);
}

static void
zeitgeist_remote_simple_indexer_proxy_search_with_relevancies_finish (ZeitgeistRemoteSimpleIndexer* self,
                                                                      GAsyncResult* _res_,
                                                                      GVariant** events,
                                                                      gdouble** relevancies,
                                                                      gint* relevancies_length1,
                                                                      guint* matches,
                                                                      GError** error)
{
	GAsyncResult *_inner_res;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	GVariant* _vala_events = NULL;
	gdouble* _vala_relevancies = NULL;
	gint _vala_relevancies_length1;
	GVariant* _tmp77_;
	gdouble* _tmp78_;
	gint _tmp78__length;
	gint _tmp78__size;
	gint _tmp78__length1;
	GVariantIter _tmp79_;
	GVariant* _tmp80_;
	guint _vala_matches = 0U;
	GVariant* _tmp81_;
	_inner_res = g_task_propagate_pointer ((GTask *) _res_, NULL);
	_reply_message = g_dbus_connection_send_message_with_reply_finish (g_dbus_proxy_get_connection ((GDBusProxy *) self), _inner_res, error);
	g_object_unref (_inner_res);
	if (!_reply_message) {
		return;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		g_object_unref (_reply_message);
		return;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_vala_events = g_variant_iter_next_value (&_reply_iter);
	*events = _vala_events;
	_vala_relevancies_length1 = 0;
	_tmp77_ = g_variant_iter_next_value (&_reply_iter);
	_tmp78_ = g_new (gdouble, 5);
	_tmp78__length = 0;
	_tmp78__size = 4;
	_tmp78__length1 = 0;
	g_variant_iter_init (&_tmp79_, _tmp77_);
	for (; (_tmp80_ = g_variant_iter_next_value (&_tmp79_)) != NULL; _tmp78__length1++) {
		if (_tmp78__size == _tmp78__length) {
			_tmp78__size = 2 * _tmp78__size;
			_tmp78_ = g_renew (gdouble, _tmp78_, _tmp78__size + 1);
		}
		_tmp78_[_tmp78__length++] = g_variant_get_double (_tmp80_);
		g_variant_unref (_tmp80_);
	}
	_vala_relevancies_length1 = _tmp78__length1;
	_vala_relevancies = _tmp78_;
	g_variant_unref (_tmp77_);
	*relevancies = _vala_relevancies;
	*relevancies_length1 = _vala_relevancies_length1;
	_tmp81_ = g_variant_iter_next_value (&_reply_iter);
	_vala_matches = g_variant_get_uint32 (_tmp81_);
	g_variant_unref (_tmp81_);
	*matches = _vala_matches;
	g_object_unref (_reply_message);
}

static void
zeitgeist_remote_simple_indexer_proxy_zeitgeist_remote_simple_indexer_interface_init (ZeitgeistRemoteSimpleIndexerIface* iface)
{
	iface->search = zeitgeist_remote_simple_indexer_proxy_search_async;
	iface->search_finish = zeitgeist_remote_simple_indexer_proxy_search_finish;
	iface->search_with_relevancies = zeitgeist_remote_simple_indexer_proxy_search_with_relevancies_async;
	iface->search_with_relevancies_finish = zeitgeist_remote_simple_indexer_proxy_search_with_relevancies_finish;
}

static void
_dbus_zeitgeist_remote_simple_indexer_search (ZeitgeistRemoteSimpleIndexer* self,
                                              GVariant* _parameters_,
                                              GDBusMethodInvocation* invocation)
{
	GVariantIter _arguments_iter;
	ZeitgeistRemoteSimpleIndexerSearchReadyData* _ready_data;
	GVariant* _tmp82_;
	GVariant* _tmp83_;
	GVariant* _tmp84_;
	GVariant* _tmp85_;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_ready_data = g_slice_new0 (ZeitgeistRemoteSimpleIndexerSearchReadyData);
	_ready_data->_invocation_ = invocation;
	_tmp82_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->query_string = g_variant_dup_string (_tmp82_, NULL);
	g_variant_unref (_tmp82_);
	_ready_data->time_range = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->filter_templates = g_variant_iter_next_value (&_arguments_iter);
	_tmp83_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->offset = g_variant_get_uint32 (_tmp83_);
	g_variant_unref (_tmp83_);
	_tmp84_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->count = g_variant_get_uint32 (_tmp84_);
	g_variant_unref (_tmp84_);
	_tmp85_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->result_type = g_variant_get_uint32 (_tmp85_);
	g_variant_unref (_tmp85_);
	zeitgeist_remote_simple_indexer_search (self, _ready_data->query_string, _ready_data->time_range, _ready_data->filter_templates, _ready_data->offset, _ready_data->count, _ready_data->result_type, NULL, (GAsyncReadyCallback) _dbus_zeitgeist_remote_simple_indexer_search_ready, _ready_data);
	_error:
	;
}

static void
_dbus_zeitgeist_remote_simple_indexer_search_ready (GObject * source_object,
                                                    GAsyncResult * _res_,
                                                    gpointer _user_data_)
{
	ZeitgeistRemoteSimpleIndexerSearchReadyData* _ready_data;
	GDBusMethodInvocation* invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	GVariant* events = NULL;
	guint matches = 0U;
	_ready_data = _user_data_;
	invocation = _ready_data->_invocation_;
	zeitgeist_remote_simple_indexer_search_finish ((ZeitgeistRemoteSimpleIndexer*) source_object, _res_, &events, &matches, &error);
	if (error) {
		g_dbus_method_invocation_take_error (invocation, error);
		goto _error;
	}
	_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, events);
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (matches));
	_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);
	_error:
	_g_free0 (_ready_data->query_string);
	_g_variant_unref0 (_ready_data->time_range);
	_g_variant_unref0 (_ready_data->filter_templates);
	_g_variant_unref0 (events);
	g_slice_free (ZeitgeistRemoteSimpleIndexerSearchReadyData, _ready_data);
}

static void
_dbus_zeitgeist_remote_simple_indexer_search_with_relevancies (ZeitgeistRemoteSimpleIndexer* self,
                                                               GVariant* _parameters_,
                                                               GDBusMethodInvocation* invocation)
{
	GVariantIter _arguments_iter;
	ZeitgeistRemoteSimpleIndexerSearchWithRelevanciesReadyData* _ready_data;
	GVariant* _tmp86_;
	GVariant* _tmp87_;
	GVariant* _tmp88_;
	GVariant* _tmp89_;
	GVariant* _tmp90_;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	_ready_data = g_slice_new0 (ZeitgeistRemoteSimpleIndexerSearchWithRelevanciesReadyData);
	_ready_data->_invocation_ = invocation;
	_tmp86_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->query_string = g_variant_dup_string (_tmp86_, NULL);
	g_variant_unref (_tmp86_);
	_ready_data->time_range = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->filter_templates = g_variant_iter_next_value (&_arguments_iter);
	_tmp87_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->storage_state = g_variant_get_uint32 (_tmp87_);
	g_variant_unref (_tmp87_);
	_tmp88_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->offset = g_variant_get_uint32 (_tmp88_);
	g_variant_unref (_tmp88_);
	_tmp89_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->count = g_variant_get_uint32 (_tmp89_);
	g_variant_unref (_tmp89_);
	_tmp90_ = g_variant_iter_next_value (&_arguments_iter);
	_ready_data->result_type = g_variant_get_uint32 (_tmp90_);
	g_variant_unref (_tmp90_);
	zeitgeist_remote_simple_indexer_search_with_relevancies (self, _ready_data->query_string, _ready_data->time_range, _ready_data->filter_templates, _ready_data->storage_state, _ready_data->offset, _ready_data->count, _ready_data->result_type, NULL, (GAsyncReadyCallback) _dbus_zeitgeist_remote_simple_indexer_search_with_relevancies_ready, _ready_data);
	_error:
	;
}

static void
_dbus_zeitgeist_remote_simple_indexer_search_with_relevancies_ready (GObject * source_object,
                                                                     GAsyncResult * _res_,
                                                                     gpointer _user_data_)
{
	ZeitgeistRemoteSimpleIndexerSearchWithRelevanciesReadyData* _ready_data;
	GDBusMethodInvocation* invocation;
	GError* error = NULL;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	GVariant* events = NULL;
	gdouble* relevancies = NULL;
	gint relevancies_length1 = 0;
	gdouble* _tmp91_;
	GVariantBuilder _tmp92_;
	gint _tmp93_;
	guint matches = 0U;
	_ready_data = _user_data_;
	invocation = _ready_data->_invocation_;
	zeitgeist_remote_simple_indexer_search_with_relevancies_finish ((ZeitgeistRemoteSimpleIndexer*) source_object, _res_, &events, &relevancies, &relevancies_length1, &matches, &error);
	if (error) {
		g_dbus_method_invocation_take_error (invocation, error);
		goto _error;
	}
	_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, events);
	_tmp91_ = relevancies;
	g_variant_builder_init (&_tmp92_, G_VARIANT_TYPE ("ad"));
	for (_tmp93_ = 0; _tmp93_ < relevancies_length1; _tmp93_++) {
		g_variant_builder_add_value (&_tmp92_, g_variant_new_double (*_tmp91_));
		_tmp91_++;
	}
	g_variant_builder_add_value (&_reply_builder, g_variant_builder_end (&_tmp92_));
	g_variant_builder_add_value (&_reply_builder, g_variant_new_uint32 (matches));
	_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);
	_error:
	_g_free0 (_ready_data->query_string);
	_g_variant_unref0 (_ready_data->time_range);
	_g_variant_unref0 (_ready_data->filter_templates);
	_g_variant_unref0 (events);
	relevancies = (g_free (relevancies), NULL);
	g_slice_free (ZeitgeistRemoteSimpleIndexerSearchWithRelevanciesReadyData, _ready_data);
}

static void
zeitgeist_remote_simple_indexer_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, "Search") == 0) {
		_dbus_zeitgeist_remote_simple_indexer_search (object, parameters, invocation);
	} else if (strcmp (method_name, "SearchWithRelevancies") == 0) {
		_dbus_zeitgeist_remote_simple_indexer_search_with_relevancies (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}

static GVariant*
zeitgeist_remote_simple_indexer_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)
{
	return NULL;
}

static gboolean
zeitgeist_remote_simple_indexer_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)
{
	return FALSE;
}

guint
zeitgeist_remote_simple_indexer_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 *) (&_zeitgeist_remote_simple_indexer_dbus_interface_info), &_zeitgeist_remote_simple_indexer_dbus_interface_vtable, data, _zeitgeist_remote_simple_indexer_unregister_object, error);
	if (!result) {
		return 0;
	}
	return result;
}

static void
_zeitgeist_remote_simple_indexer_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);
}

guint32
zeitgeist_network_manager_dbus_state (ZeitgeistNetworkManagerDBus* self,
                                      GError** error)
{
	ZeitgeistNetworkManagerDBusIface* _iface_;
	g_return_val_if_fail (self != NULL, 0U);
	_iface_ = ZEITGEIST_NETWORK_MANAGER_DBUS_GET_INTERFACE (self);
	if (_iface_->state) {
		return _iface_->state (self, error);
	}
	return 0U;
}

static void
zeitgeist_network_manager_dbus_default_init (ZeitgeistNetworkManagerDBusIface * iface,
                                             gpointer iface_data)
{
	zeitgeist_network_manager_dbus_signals[ZEITGEIST_NETWORK_MANAGER_DBUS_STATE_CHANGED_SIGNAL] = g_signal_new ("state-changed", ZEITGEIST_TYPE_NETWORK_MANAGER_DBUS, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__UINT, G_TYPE_NONE, 1, G_TYPE_UINT);
}

static GType
zeitgeist_network_manager_dbus_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ZeitgeistNetworkManagerDBusIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) zeitgeist_network_manager_dbus_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
	GType zeitgeist_network_manager_dbus_type_id;
	zeitgeist_network_manager_dbus_type_id = g_type_register_static (G_TYPE_INTERFACE, "ZeitgeistNetworkManagerDBus", &g_define_type_info, 0);
	g_type_interface_add_prerequisite (zeitgeist_network_manager_dbus_type_id, G_TYPE_OBJECT);
	g_type_set_qdata (zeitgeist_network_manager_dbus_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) zeitgeist_network_manager_dbus_proxy_get_type);
	g_type_set_qdata (zeitgeist_network_manager_dbus_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "org.freedesktop.NetworkManager");
	g_type_set_qdata (zeitgeist_network_manager_dbus_type_id, g_quark_from_static_string ("vala-dbus-interface-info"), (void*) (&_zeitgeist_network_manager_dbus_dbus_interface_info));
	g_type_set_qdata (zeitgeist_network_manager_dbus_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) zeitgeist_network_manager_dbus_register_object);
	return zeitgeist_network_manager_dbus_type_id;
}

GType
zeitgeist_network_manager_dbus_get_type (void)
{
	static volatile gsize zeitgeist_network_manager_dbus_type_id__once = 0;
	if (g_once_init_enter (&zeitgeist_network_manager_dbus_type_id__once)) {
		GType zeitgeist_network_manager_dbus_type_id;
		zeitgeist_network_manager_dbus_type_id = zeitgeist_network_manager_dbus_get_type_once ();
		g_once_init_leave (&zeitgeist_network_manager_dbus_type_id__once, zeitgeist_network_manager_dbus_type_id);
	}
	return zeitgeist_network_manager_dbus_type_id__once;
}

G_DEFINE_TYPE_EXTENDED (ZeitgeistNetworkManagerDBusProxy, zeitgeist_network_manager_dbus_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (ZEITGEIST_TYPE_NETWORK_MANAGER_DBUS, zeitgeist_network_manager_dbus_proxy_zeitgeist_network_manager_dbus_interface_init) )
static void
zeitgeist_network_manager_dbus_proxy_class_init (ZeitgeistNetworkManagerDBusProxyClass* klass)
{
	G_DBUS_PROXY_CLASS (klass)->g_signal = zeitgeist_network_manager_dbus_proxy_g_signal;
}

static void
_dbus_handle_zeitgeist_network_manager_dbus_state_changed (ZeitgeistNetworkManagerDBus* self,
                                                           GVariant* parameters)
{
	GVariantIter _arguments_iter;
	guint32 state = 0U;
	GVariant* _tmp94_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp94_ = g_variant_iter_next_value (&_arguments_iter);
	state = g_variant_get_uint32 (_tmp94_);
	g_variant_unref (_tmp94_);
	g_signal_emit_by_name (self, "state-changed", state);
}

static void
zeitgeist_network_manager_dbus_proxy_g_signal (GDBusProxy* proxy,
                                               const gchar* sender_name,
                                               const gchar* signal_name,
                                               GVariant* parameters)
{
	if (strcmp (signal_name, "StateChanged") == 0) {
		_dbus_handle_zeitgeist_network_manager_dbus_state_changed ((ZeitgeistNetworkManagerDBus*) proxy, parameters);
	}
}

static void
zeitgeist_network_manager_dbus_proxy_init (ZeitgeistNetworkManagerDBusProxy* self)
{
	g_dbus_proxy_set_interface_info (G_DBUS_PROXY (self), (GDBusInterfaceInfo *) (&_zeitgeist_network_manager_dbus_dbus_interface_info));
}

static guint32
zeitgeist_network_manager_dbus_proxy_state (ZeitgeistNetworkManagerDBus* self,
                                            GError** error)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	guint32 _result = 0U;
	GVariant* _tmp97_;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "org.freedesktop.NetworkManager", "state");
	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) {
		guint32 _tmp95_ = 0U;
		return _tmp95_;
	}
	if (g_dbus_message_to_gerror (_reply_message, error)) {
		guint32 _tmp96_ = 0U;
		g_object_unref (_reply_message);
		return _tmp96_;
	}
	_reply = g_dbus_message_get_body (_reply_message);
	g_variant_iter_init (&_reply_iter, _reply);
	_tmp97_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_get_uint32 (_tmp97_);
	g_variant_unref (_tmp97_);
	g_object_unref (_reply_message);
	return _result;
}

static void
zeitgeist_network_manager_dbus_proxy_zeitgeist_network_manager_dbus_interface_init (ZeitgeistNetworkManagerDBusIface* iface)
{
	iface->state = zeitgeist_network_manager_dbus_proxy_state;
}

static void
_dbus_zeitgeist_network_manager_dbus_state (ZeitgeistNetworkManagerDBus* self,
                                            GVariant* _parameters_,
                                            GDBusMethodInvocation* invocation)
{
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	guint32 result;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	result = zeitgeist_network_manager_dbus_state (self, &error);
	if (error) {
		g_dbus_method_invocation_take_error (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
zeitgeist_network_manager_dbus_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, "state") == 0) {
		_dbus_zeitgeist_network_manager_dbus_state (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}

static GVariant*
zeitgeist_network_manager_dbus_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)
{
	return NULL;
}

static gboolean
zeitgeist_network_manager_dbus_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)
{
	return FALSE;
}

static void
_dbus_zeitgeist_network_manager_dbus_state_changed (GObject* _sender,
                                                    guint32 state,
                                                    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_uint32 (state));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_connection_emit_signal (_connection, NULL, _path, "org.freedesktop.NetworkManager", "StateChanged", _arguments, NULL);
}

guint
zeitgeist_network_manager_dbus_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 *) (&_zeitgeist_network_manager_dbus_dbus_interface_info), &_zeitgeist_network_manager_dbus_dbus_interface_vtable, data, _zeitgeist_network_manager_dbus_unregister_object, error);
	if (!result) {
		return 0;
	}
	g_signal_connect (object, "state-changed", (GCallback) _dbus_zeitgeist_network_manager_dbus_state_changed, data);
	return result;
}

static void
_zeitgeist_network_manager_dbus_unregister_object (gpointer user_data)
{
	gpointer* data;
	data = user_data;
	g_signal_handlers_disconnect_by_func (data[0], _dbus_zeitgeist_network_manager_dbus_state_changed, data);
	g_object_unref (data[0]);
	g_object_unref (data[1]);
	g_free (data[2]);
	g_free (data);
}

gchar*
zeitgeist_connman_manager_dbus_get_state (ZeitgeistConnmanManagerDBus* self,
                                          GError** error)
{
	ZeitgeistConnmanManagerDBusIface* _iface_;
	g_return_val_if_fail (self != NULL, NULL);
	_iface_ = ZEITGEIST_CONNMAN_MANAGER_DBUS_GET_INTERFACE (self);
	if (_iface_->get_state) {
		return _iface_->get_state (self, error);
	}
	return NULL;
}

static void
zeitgeist_connman_manager_dbus_default_init (ZeitgeistConnmanManagerDBusIface * iface,
                                             gpointer iface_data)
{
	zeitgeist_connman_manager_dbus_signals[ZEITGEIST_CONNMAN_MANAGER_DBUS_STATE_CHANGED_SIGNAL] = g_signal_new ("state-changed", ZEITGEIST_TYPE_CONNMAN_MANAGER_DBUS, G_SIGNAL_RUN_LAST, 0, NULL, NULL, g_cclosure_marshal_VOID__STRING, G_TYPE_NONE, 1, G_TYPE_STRING);
}

static GType
zeitgeist_connman_manager_dbus_get_type_once (void)
{
	static const GTypeInfo g_define_type_info = { sizeof (ZeitgeistConnmanManagerDBusIface), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) zeitgeist_connman_manager_dbus_default_init, (GClassFinalizeFunc) NULL, NULL, 0, 0, (GInstanceInitFunc) NULL, NULL };
	GType zeitgeist_connman_manager_dbus_type_id;
	zeitgeist_connman_manager_dbus_type_id = g_type_register_static (G_TYPE_INTERFACE, "ZeitgeistConnmanManagerDBus", &g_define_type_info, 0);
	g_type_interface_add_prerequisite (zeitgeist_connman_manager_dbus_type_id, G_TYPE_OBJECT);
	g_type_set_qdata (zeitgeist_connman_manager_dbus_type_id, g_quark_from_static_string ("vala-dbus-proxy-type"), (void*) zeitgeist_connman_manager_dbus_proxy_get_type);
	g_type_set_qdata (zeitgeist_connman_manager_dbus_type_id, g_quark_from_static_string ("vala-dbus-interface-name"), "net.connman.Manager");
	g_type_set_qdata (zeitgeist_connman_manager_dbus_type_id, g_quark_from_static_string ("vala-dbus-interface-info"), (void*) (&_zeitgeist_connman_manager_dbus_dbus_interface_info));
	g_type_set_qdata (zeitgeist_connman_manager_dbus_type_id, g_quark_from_static_string ("vala-dbus-register-object"), (void*) zeitgeist_connman_manager_dbus_register_object);
	return zeitgeist_connman_manager_dbus_type_id;
}

GType
zeitgeist_connman_manager_dbus_get_type (void)
{
	static volatile gsize zeitgeist_connman_manager_dbus_type_id__once = 0;
	if (g_once_init_enter (&zeitgeist_connman_manager_dbus_type_id__once)) {
		GType zeitgeist_connman_manager_dbus_type_id;
		zeitgeist_connman_manager_dbus_type_id = zeitgeist_connman_manager_dbus_get_type_once ();
		g_once_init_leave (&zeitgeist_connman_manager_dbus_type_id__once, zeitgeist_connman_manager_dbus_type_id);
	}
	return zeitgeist_connman_manager_dbus_type_id__once;
}

G_DEFINE_TYPE_EXTENDED (ZeitgeistConnmanManagerDBusProxy, zeitgeist_connman_manager_dbus_proxy, G_TYPE_DBUS_PROXY, 0, G_IMPLEMENT_INTERFACE (ZEITGEIST_TYPE_CONNMAN_MANAGER_DBUS, zeitgeist_connman_manager_dbus_proxy_zeitgeist_connman_manager_dbus_interface_init) )
static void
zeitgeist_connman_manager_dbus_proxy_class_init (ZeitgeistConnmanManagerDBusProxyClass* klass)
{
	G_DBUS_PROXY_CLASS (klass)->g_signal = zeitgeist_connman_manager_dbus_proxy_g_signal;
}

static void
_dbus_handle_zeitgeist_connman_manager_dbus_state_changed (ZeitgeistConnmanManagerDBus* self,
                                                           GVariant* parameters)
{
	GVariantIter _arguments_iter;
	gchar* state = NULL;
	GVariant* _tmp98_;
	g_variant_iter_init (&_arguments_iter, parameters);
	_tmp98_ = g_variant_iter_next_value (&_arguments_iter);
	state = g_variant_dup_string (_tmp98_, NULL);
	g_variant_unref (_tmp98_);
	g_signal_emit_by_name (self, "state-changed", state);
	_g_free0 (state);
}

static void
zeitgeist_connman_manager_dbus_proxy_g_signal (GDBusProxy* proxy,
                                               const gchar* sender_name,
                                               const gchar* signal_name,
                                               GVariant* parameters)
{
	if (strcmp (signal_name, "StateChanged") == 0) {
		_dbus_handle_zeitgeist_connman_manager_dbus_state_changed ((ZeitgeistConnmanManagerDBus*) proxy, parameters);
	}
}

static void
zeitgeist_connman_manager_dbus_proxy_init (ZeitgeistConnmanManagerDBusProxy* self)
{
	g_dbus_proxy_set_interface_info (G_DBUS_PROXY (self), (GDBusInterfaceInfo *) (&_zeitgeist_connman_manager_dbus_dbus_interface_info));
}

static gchar*
zeitgeist_connman_manager_dbus_proxy_get_state (ZeitgeistConnmanManagerDBus* self,
                                                GError** error)
{
	GDBusMessage *_message;
	GVariant *_arguments;
	GVariantBuilder _arguments_builder;
	GDBusMessage *_reply_message;
	GVariant *_reply;
	GVariantIter _reply_iter;
	gchar* _result = NULL;
	GVariant* _tmp99_;
	_message = g_dbus_message_new_method_call (g_dbus_proxy_get_name ((GDBusProxy *) self), g_dbus_proxy_get_object_path ((GDBusProxy *) self), "net.connman.Manager", "GetState");
	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);
	_tmp99_ = g_variant_iter_next_value (&_reply_iter);
	_result = g_variant_dup_string (_tmp99_, NULL);
	g_variant_unref (_tmp99_);
	g_object_unref (_reply_message);
	return _result;
}

static void
zeitgeist_connman_manager_dbus_proxy_zeitgeist_connman_manager_dbus_interface_init (ZeitgeistConnmanManagerDBusIface* iface)
{
	iface->get_state = zeitgeist_connman_manager_dbus_proxy_get_state;
}

static void
_dbus_zeitgeist_connman_manager_dbus_get_state (ZeitgeistConnmanManagerDBus* self,
                                                GVariant* _parameters_,
                                                GDBusMethodInvocation* invocation)
{
	GError* error = NULL;
	GVariantIter _arguments_iter;
	GDBusMessage* _reply_message = NULL;
	GVariant* _reply;
	GVariantBuilder _reply_builder;
	gchar* result;
	g_variant_iter_init (&_arguments_iter, _parameters_);
	result = zeitgeist_connman_manager_dbus_get_state (self, &error);
	if (error) {
		g_dbus_method_invocation_take_error (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
zeitgeist_connman_manager_dbus_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, "GetState") == 0) {
		_dbus_zeitgeist_connman_manager_dbus_get_state (object, parameters, invocation);
	} else {
		g_object_unref (invocation);
	}
}

static GVariant*
zeitgeist_connman_manager_dbus_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)
{
	return NULL;
}

static gboolean
zeitgeist_connman_manager_dbus_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)
{
	return FALSE;
}

static void
_dbus_zeitgeist_connman_manager_dbus_state_changed (GObject* _sender,
                                                    const gchar* state,
                                                    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 (state));
	_arguments = g_variant_builder_end (&_arguments_builder);
	g_dbus_connection_emit_signal (_connection, NULL, _path, "net.connman.Manager", "StateChanged", _arguments, NULL);
}

guint
zeitgeist_connman_manager_dbus_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 *) (&_zeitgeist_connman_manager_dbus_dbus_interface_info), &_zeitgeist_connman_manager_dbus_dbus_interface_vtable, data, _zeitgeist_connman_manager_dbus_unregister_object, error);
	if (!result) {
		return 0;
	}
	g_signal_connect (object, "state-changed", (GCallback) _dbus_zeitgeist_connman_manager_dbus_state_changed, data);
	return result;
}

static void
_zeitgeist_connman_manager_dbus_unregister_object (gpointer user_data)
{
	gpointer* data;
	data = user_data;
	g_signal_handlers_disconnect_by_func (data[0], _dbus_zeitgeist_connman_manager_dbus_state_changed, data);
	g_object_unref (data[0]);
	g_object_unref (data[1]);
	g_free (data[2]);
	g_free (data);
}

static void
_vala_array_destroy (gpointer array,
                     gssize array_length,
                     GDestroyNotify destroy_func)
{
	if ((array != NULL) && (destroy_func != NULL)) {
		gssize 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,
                  gssize array_length,
                  GDestroyNotify destroy_func)
{
	_vala_array_destroy (array, array_length, destroy_func);
	g_free (array);
}

static inline gpointer
_vala_memdup2 (gconstpointer mem,
               gsize byte_size)
{
	gpointer new_mem;
	if (mem && byte_size != 0) {
		new_mem = g_malloc (byte_size);
		memcpy (new_mem, mem, byte_size);
	} else {
		new_mem = NULL;
	}
	return new_mem;
}

