e_gdbus_templates_init_main_thread ()

void
e_gdbus_templates_init_main_thread (void);

e_gdbus_async_op_keeper_create_pending_ops ()

GHashTable *
e_gdbus_async_op_keeper_create_pending_ops
                               (EGdbusAsyncOpKeeper *object);

Create a hash table of pending async operations. This can be freed with g_hash_table_unref() in dispose. The interface asks for this pointer by calling e_gdbus_async_op_keeper_create_pending_ops().

e_gdbus_async_op_keeper_get_pending_ops ()

GHashTable *
e_gdbus_async_op_keeper_get_pending_ops
                               (EGdbusAsyncOpKeeper *object);

Get the hash table of pending async operations previously created by e_gdbus_async_op_keeper_create_pending_ops().

e_gdbus_async_op_keeper_cancel_op_sync ()

gboolean
e_gdbus_async_op_keeper_cancel_op_sync
                               (EGdbusAsyncOpKeeper *object,
                                guint in_opid,
                                GCancellable *cancellable,
                                GError **error);

E_DECLARE_GDBUS_ARG()

#define             E_DECLARE_GDBUS_ARG(_where, _mname, _mtype, _param_name, _param_type)

E_DECLARE_GDBUS_NOTIFY_SIGNAL_0()

#define             E_DECLARE_GDBUS_NOTIFY_SIGNAL_0(_where, _sname)

E_DECLARE_GDBUS_NOTIFY_SIGNAL_1()

#define             E_DECLARE_GDBUS_NOTIFY_SIGNAL_1(_where, _sname, _p1_name, _p1_type)

E_DECLARE_GDBUS_NOTIFY_SIGNAL_2()

#define             E_DECLARE_GDBUS_NOTIFY_SIGNAL_2(_where, _sname, _p1_name, _p1_type, _p2_name, _p2_type)

E_DECLARE_GDBUS_ASYNC_DONE_SIGNAL_0()

#define             E_DECLARE_GDBUS_ASYNC_DONE_SIGNAL_0(_where, _sname)

E_DECLARE_GDBUS_ASYNC_DONE_SIGNAL_1()

#define             E_DECLARE_GDBUS_ASYNC_DONE_SIGNAL_1(_where, _sname, _p1_name, _p1_type)

E_DECLARE_GDBUS_SYNC_METHOD_0()

#define             E_DECLARE_GDBUS_SYNC_METHOD_0(_where, _mname)

E_DECLARE_GDBUS_SYNC_METHOD_1()

#define             E_DECLARE_GDBUS_SYNC_METHOD_1(_where, _mname, _p1_name, _p1_type)

E_DECLARE_GDBUS_SYNC_METHOD_0_WITH_RETURN()

#define             E_DECLARE_GDBUS_SYNC_METHOD_0_WITH_RETURN(_where, _mname, _r1_name, _r1_type)

E_DECLARE_GDBUS_SYNC_METHOD_1_WITH_RETURN()

#define             E_DECLARE_GDBUS_SYNC_METHOD_1_WITH_RETURN(_where, _mname, _p1_name, _p1_type, _r1_name, _r1_type)

E_DECLARE_GDBUS_ASYNC_METHOD_0()

#define             E_DECLARE_GDBUS_ASYNC_METHOD_0(_where, _mname)

E_DECLARE_GDBUS_ASYNC_METHOD_1()

#define             E_DECLARE_GDBUS_ASYNC_METHOD_1(_where, _mname, _p1_name, _p1_type)

E_DECLARE_GDBUS_ASYNC_METHOD_0_WITH_RETURN()

#define             E_DECLARE_GDBUS_ASYNC_METHOD_0_WITH_RETURN(_where, _mname, _r1_name, _r1_type)

E_DECLARE_GDBUS_ASYNC_METHOD_1_WITH_RETURN()

#define             E_DECLARE_GDBUS_ASYNC_METHOD_1_WITH_RETURN(_where, _mname, _p1_name, _p1_type, _r1_name, _r1_type)

E_DECLARED_GDBUS_SIGNAL_INFO_NAME()

#define E_DECLARED_GDBUS_SIGNAL_INFO_NAME(_where, _sname) e_gdbus_ ## _where ## _signal_ ## _sname

E_DECLARED_GDBUS_METHOD_INFO_NAME()

#define E_DECLARED_GDBUS_METHOD_INFO_NAME(_where, _mname) e_gdbus_ ## _where ## _method_ ## _mname

E_INIT_GDBUS_SIGNAL_VOID()

#define             E_INIT_GDBUS_SIGNAL_VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)

E_INIT_GDBUS_SIGNAL_TMPL_TYPED()

#define             E_INIT_GDBUS_SIGNAL_TMPL_TYPED(_mtype, _gtype, _iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)

E_INIT_GDBUS_SIGNAL_BOOLEAN()

#define             E_INIT_GDBUS_SIGNAL_BOOLEAN(_iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)

E_INIT_GDBUS_SIGNAL_STRING()

#define             E_INIT_GDBUS_SIGNAL_STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)

E_INIT_GDBUS_SIGNAL_STRV()

#define             E_INIT_GDBUS_SIGNAL_STRV(_iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)

E_INIT_GDBUS_SIGNAL_UINT()

#define             E_INIT_GDBUS_SIGNAL_UINT(_iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)

E_INIT_GDBUS_SIGNAL_UINT_STRING()

#define             E_INIT_GDBUS_SIGNAL_UINT_STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _sig_id)

E_INIT_GDBUS_METHOD_DONE_VOID()

#define             E_INIT_GDBUS_METHOD_DONE_VOID(_iface_struct, _sig_name_var, _done_sig_id)

E_INIT_GDBUS_METHOD_DONE_ASYNC_TMPL_TYPED()

#define             E_INIT_GDBUS_METHOD_DONE_ASYNC_TMPL_TYPED(_mtype, _gtype, _iface_struct, _sig_name_var, _done_sig_id)

E_INIT_GDBUS_METHOD_DONE_BOOLEAN()

#define             E_INIT_GDBUS_METHOD_DONE_BOOLEAN(_iface_struct, _sig_name_var, _done_sig_id)

E_INIT_GDBUS_METHOD_DONE_STRING()

#define             E_INIT_GDBUS_METHOD_DONE_STRING(_iface_struct, _sig_name_var, _done_sig_id)

E_INIT_GDBUS_METHOD_DONE_STRV()

#define             E_INIT_GDBUS_METHOD_DONE_STRV(_iface_struct, _sig_name_var, _done_sig_id)

E_INIT_GDBUS_METHOD_DONE_UINT()

#define             E_INIT_GDBUS_METHOD_DONE_UINT(_iface_struct, _sig_name_var, _done_sig_id)

E_INIT_GDBUS_METHOD_CALL_TMPL_VOID()

#define             E_INIT_GDBUS_METHOD_CALL_TMPL_VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)

E_INIT_GDBUS_METHOD_CALL_TMPL_TYPED()

#define             E_INIT_GDBUS_METHOD_CALL_TMPL_TYPED(_mtype, _gtype, _iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)

E_INIT_GDBUS_METHOD_VOID()

#define             E_INIT_GDBUS_METHOD_VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)

E_INIT_GDBUS_METHOD_BOOLEAN()

#define             E_INIT_GDBUS_METHOD_BOOLEAN(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)

E_INIT_GDBUS_METHOD_STRING()

#define             E_INIT_GDBUS_METHOD_STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)

E_INIT_GDBUS_METHOD_STRV()

#define             E_INIT_GDBUS_METHOD_STRV(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)

E_INIT_GDBUS_METHOD_UINT()

#define             E_INIT_GDBUS_METHOD_UINT(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)

E_INIT_GDBUS_METHOD_CALL_VOID()

#define             E_INIT_GDBUS_METHOD_CALL_VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)

E_INIT_GDBUS_METHOD_CALL_BOOLEAN()

#define             E_INIT_GDBUS_METHOD_CALL_BOOLEAN(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)

E_INIT_GDBUS_METHOD_CALL_STRING()

#define             E_INIT_GDBUS_METHOD_CALL_STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)

E_INIT_GDBUS_METHOD_CALL_STRV()

#define             E_INIT_GDBUS_METHOD_CALL_STRV(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)

E_INIT_GDBUS_METHOD_CALL_UINT()

#define             E_INIT_GDBUS_METHOD_CALL_UINT(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id)

E_INIT_GDBUS_METHOD_ASYNC_VOID__VOID()

#define             E_INIT_GDBUS_METHOD_ASYNC_VOID__VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)

E_INIT_GDBUS_METHOD_ASYNC_VOID__STRING()

#define             E_INIT_GDBUS_METHOD_ASYNC_VOID__STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)

E_INIT_GDBUS_METHOD_ASYNC_VOID__STRV()

#define             E_INIT_GDBUS_METHOD_ASYNC_VOID__STRV(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)

E_INIT_GDBUS_METHOD_ASYNC_BOOLEAN__VOID()

#define             E_INIT_GDBUS_METHOD_ASYNC_BOOLEAN__VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)

E_INIT_GDBUS_METHOD_ASYNC_UINT__VOID()

#define             E_INIT_GDBUS_METHOD_ASYNC_UINT__VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)

E_INIT_GDBUS_METHOD_ASYNC_STRING__VOID()

#define             E_INIT_GDBUS_METHOD_ASYNC_STRING__VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)

E_INIT_GDBUS_METHOD_ASYNC_STRV__VOID()

#define             E_INIT_GDBUS_METHOD_ASYNC_STRV__VOID(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)

E_INIT_GDBUS_METHOD_ASYNC_STRING__STRING()

#define             E_INIT_GDBUS_METHOD_ASYNC_STRING__STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)

E_INIT_GDBUS_METHOD_ASYNC_STRING__STRV()

#define             E_INIT_GDBUS_METHOD_ASYNC_STRING__STRV(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)

E_INIT_GDBUS_METHOD_ASYNC_STRV__STRING()

#define             E_INIT_GDBUS_METHOD_ASYNC_STRV__STRING(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)

E_INIT_GDBUS_METHOD_ASYNC_STRV__STRV()

#define             E_INIT_GDBUS_METHOD_ASYNC_STRV__STRV(_iface_struct, _dbus_sig_name_str, _sig_name_var, _method_sig_id, _done_sig_id)

E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_VOID()

#define             E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_VOID(_iface_name, _sig_name)

E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_BOOLEAN()

#define             E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_BOOLEAN(_iface_name, _sig_name)

E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_STRING()

#define             E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_STRING(_iface_name, _sig_name)

E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_STRV()

#define             E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_STRV(_iface_name, _sig_name)

E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_UINT()

#define             E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_UINT(_iface_name, _sig_name)

E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_UINT_STRING()

#define             E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_UINT_STRING(_iface_name, _sig_name)

E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_VOID()

#define             E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_VOID(_iface_name, _sig_name)

E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_BOOLEAN()

#define             E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_BOOLEAN(_iface_name, _sig_name)

E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_STRING()

#define             E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_STRING(_iface_name, _sig_name)

E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_STRV()

#define             E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_STRV(_iface_name, _sig_name)

E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_UINT()

#define             E_DECLARE_GDBUS_SIGNAL_EMISSION_HOOK_ASYNC_UINT(_iface_name, _sig_name)

E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_VOID()

#define             E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_VOID(_iface_name, _sig_name)

E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_BOOLEAN()

#define             E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_BOOLEAN(_iface_name, _sig_name)

E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRING()

#define             E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRING(_iface_name, _sig_name)

E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRV()

#define             E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_STRV(_iface_name, _sig_name)

E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_UINT()

#define             E_DECLARE_GDBUS_METHOD_DONE_EMISSION_HOOK_ASYNC_UINT(_iface_name, _sig_name)

E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_VOID()

#define             E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_VOID(_sig_name)

E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_BOOLEAN()

#define             E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_BOOLEAN(_sig_name)

E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRING()

#define             E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRING(_sig_name)

E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRV()

#define             E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_STRV(_sig_name)

E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_UINT()

#define             E_GDBUS_CONNECT_METHOD_DONE_SIGNAL_UINT(_sig_name)

e_gdbus_proxy_emit_signal ()

void
e_gdbus_proxy_emit_signal (GDBusProxy *proxy,
                           GVariant *parameters,
                           guint signal_id,
                           guint signal_type);

e_gdbus_stub_handle_method_call ()

void
e_gdbus_stub_handle_method_call (GObject *stub_object,
                                 GDBusMethodInvocation *invocation,
                                 GVariant *parameters,
                                 const gchar *method_name,
                                 guint method_id,
                                 guint method_type);

e_gdbus_signal_emission_hook_void ()

gboolean
e_gdbus_signal_emission_hook_void (GSignalInvocationHint *ihint,
                                   guint n_param_values,
                                   const GValue *param_values,
                                   const gchar *signal_name,
                                   const gchar *iface_name);

e_gdbus_signal_emission_hook_boolean ()

gboolean
e_gdbus_signal_emission_hook_boolean (GSignalInvocationHint *ihint,
                                      guint n_param_values,
                                      const GValue *param_values,
                                      const gchar *signal_name,
                                      const gchar *iface_name);

e_gdbus_signal_emission_hook_string ()

gboolean
e_gdbus_signal_emission_hook_string (GSignalInvocationHint *ihint,
                                     guint n_param_values,
                                     const GValue *param_values,
                                     const gchar *signal_name,
                                     const gchar *iface_name);

e_gdbus_signal_emission_hook_strv ()

gboolean
e_gdbus_signal_emission_hook_strv (GSignalInvocationHint *ihint,
                                   guint n_param_values,
                                   const GValue *param_values,
                                   const gchar *signal_name,
                                   const gchar *iface_name);

e_gdbus_signal_emission_hook_uint ()

gboolean
e_gdbus_signal_emission_hook_uint (GSignalInvocationHint *ihint,
                                   guint n_param_values,
                                   const GValue *param_values,
                                   const gchar *signal_name,
                                   const gchar *iface_name);

e_gdbus_signal_emission_hook_uint_string ()

gboolean
e_gdbus_signal_emission_hook_uint_string
                               (GSignalInvocationHint *ihint,
                                guint n_param_values,
                                const GValue *param_values,
                                const gchar *signal_name,
                                const gchar *iface_name);

e_gdbus_signal_emission_hook_async_void ()

gboolean
e_gdbus_signal_emission_hook_async_void
                               (GSignalInvocationHint *ihint,
                                guint n_param_values,
                                const GValue *param_values,
                                const gchar *signal_name,
                                const gchar *iface_name);

e_gdbus_signal_emission_hook_async_boolean ()

gboolean
e_gdbus_signal_emission_hook_async_boolean
                               (GSignalInvocationHint *ihint,
                                guint n_param_values,
                                const GValue *param_values,
                                const gchar *signal_name,
                                const gchar *iface_name);

e_gdbus_signal_emission_hook_async_string ()

gboolean
e_gdbus_signal_emission_hook_async_string
                               (GSignalInvocationHint *ihint,
                                guint n_param_values,
                                const GValue *param_values,
                                const gchar *signal_name,
                                const gchar *iface_name);

e_gdbus_signal_emission_hook_async_strv ()

gboolean
e_gdbus_signal_emission_hook_async_strv
                               (GSignalInvocationHint *ihint,
                                guint n_param_values,
                                const GValue *param_values,
                                const gchar *signal_name,
                                const gchar *iface_name);

e_gdbus_signal_emission_hook_async_uint ()

gboolean
e_gdbus_signal_emission_hook_async_uint
                               (GSignalInvocationHint *ihint,
                                guint n_param_values,
                                const GValue *param_values,
                                const gchar *signal_name,
                                const gchar *iface_name);

e_gdbus_complete_async_method ()

void
e_gdbus_complete_async_method (gpointer object,
                               GDBusMethodInvocation *invocation,
                               guint opid);

e_gdbus_complete_sync_method_void ()

void
e_gdbus_complete_sync_method_void (gpointer object,
                                   GDBusMethodInvocation *invocation,
                                   const GError *error);

e_gdbus_complete_sync_method_boolean ()

void
e_gdbus_complete_sync_method_boolean (gpointer object,
                                      GDBusMethodInvocation *invocation,
                                      gboolean out_boolean,
                                      const GError *error);

e_gdbus_complete_sync_method_string ()

void
e_gdbus_complete_sync_method_string (gpointer object,
                                     GDBusMethodInvocation *invocation,
                                     const gchar *out_string,
                                     const GError *error);

e_gdbus_complete_sync_method_strv ()

void
e_gdbus_complete_sync_method_strv (gpointer object,
                                   GDBusMethodInvocation *invocation,
                                   const gchar * const *out_strv,
                                   const GError *error);

e_gdbus_complete_sync_method_uint ()

void
e_gdbus_complete_sync_method_uint (gpointer object,
                                   GDBusMethodInvocation *invocation,
                                   guint out_uint,
                                   const GError *error);

e_gdbus_proxy_async_method_done_void ()

void
e_gdbus_proxy_async_method_done_void (EGdbusAsyncOpKeeper *proxy,
                                      guint arg_opid,
                                      const GError *error);

e_gdbus_proxy_async_method_done_boolean ()

void
e_gdbus_proxy_async_method_done_boolean
                               (EGdbusAsyncOpKeeper *proxy,
                                guint arg_opid,
                                const GError *error,
                                gboolean out_boolean);

e_gdbus_proxy_async_method_done_string ()

void
e_gdbus_proxy_async_method_done_string
                               (EGdbusAsyncOpKeeper *proxy,
                                guint arg_opid,
                                const GError *error,
                                const gchar *out_string);

e_gdbus_proxy_async_method_done_strv ()

void
e_gdbus_proxy_async_method_done_strv (EGdbusAsyncOpKeeper *proxy,
                                      guint arg_opid,
                                      const GError *error,
                                      const gchar * const *out_strv);

e_gdbus_proxy_async_method_done_uint ()

void
e_gdbus_proxy_async_method_done_uint (EGdbusAsyncOpKeeper *proxy,
                                      guint arg_opid,
                                      const GError *error,
                                      guint out_uint);

e_gdbus_proxy_call_void ()

void
e_gdbus_proxy_call_void (const gchar *method_name,
                         gpointer source_tag,
                         EGdbusAsyncOpKeeper *proxy,
                         GCancellable *cancellable,
                         GAsyncReadyCallback callback,
                         gpointer user_data);

e_gdbus_proxy_call_boolean ()

void
e_gdbus_proxy_call_boolean (const gchar *method_name,
                            gpointer source_tag,
                            EGdbusAsyncOpKeeper *proxy,
                            gboolean in_boolean,
                            GCancellable *cancellable,
                            GAsyncReadyCallback callback,
                            gpointer user_data);

e_gdbus_proxy_call_string ()

void
e_gdbus_proxy_call_string (const gchar *method_name,
                           gpointer source_tag,
                           EGdbusAsyncOpKeeper *proxy,
                           const gchar *in_string,
                           GCancellable *cancellable,
                           GAsyncReadyCallback callback,
                           gpointer user_data);

e_gdbus_proxy_call_strv ()

void
e_gdbus_proxy_call_strv (const gchar *method_name,
                         gpointer source_tag,
                         EGdbusAsyncOpKeeper *proxy,
                         const gchar * const *in_strv,
                         GCancellable *cancellable,
                         GAsyncReadyCallback callback,
                         gpointer user_data);

e_gdbus_proxy_call_uint ()

void
e_gdbus_proxy_call_uint (const gchar *method_name,
                         gpointer source_tag,
                         EGdbusAsyncOpKeeper *proxy,
                         guint in_uint,
                         GCancellable *cancellable,
                         GAsyncReadyCallback callback,
                         gpointer user_data);

e_gdbus_proxy_finish_call_void ()

gboolean
e_gdbus_proxy_finish_call_void (EGdbusAsyncOpKeeper *proxy,
                                GAsyncResult *result,
                                GError **error,
                                gpointer source_tag);

e_gdbus_proxy_finish_call_boolean ()

gboolean
e_gdbus_proxy_finish_call_boolean (EGdbusAsyncOpKeeper *proxy,
                                   GAsyncResult *result,
                                   gboolean *out_boolean,
                                   GError **error,
                                   gpointer source_tag);

e_gdbus_proxy_finish_call_string ()

gboolean
e_gdbus_proxy_finish_call_string (EGdbusAsyncOpKeeper *proxy,
                                  GAsyncResult *result,
                                  gchar **out_string,
                                  GError **error,
                                  gpointer source_tag);

e_gdbus_proxy_finish_call_strv ()

gboolean
e_gdbus_proxy_finish_call_strv (EGdbusAsyncOpKeeper *proxy,
                                GAsyncResult *result,
                                gchar ***out_strv,
                                GError **error,
                                gpointer source_tag);

e_gdbus_proxy_finish_call_uint ()

gboolean
e_gdbus_proxy_finish_call_uint (EGdbusAsyncOpKeeper *proxy,
                                GAsyncResult *result,
                                guint *out_uint,
                                GError **error,
                                gpointer source_tag);

EGdbusCallStartVoid ()

void
(*EGdbusCallStartVoid) (GDBusProxy *proxy,
                        GCancellable *cancellable,
                        GAsyncReadyCallback callback,
                        gpointer user_data);

EGdbusCallStartBoolean ()

void
(*EGdbusCallStartBoolean) (GDBusProxy *proxy,
                           gboolean in_boolean,
                           GCancellable *cancellable,
                           GAsyncReadyCallback callback,
                           gpointer user_data);

EGdbusCallStartString ()

void
(*EGdbusCallStartString) (GDBusProxy *proxy,
                          const gchar *in_string,
                          GCancellable *cancellable,
                          GAsyncReadyCallback callback,
                          gpointer user_data);

EGdbusCallStartStrv ()

void
(*EGdbusCallStartStrv) (GDBusProxy *proxy,
                        const gchar * const *in_strv,
                        GCancellable *cancellable,
                        GAsyncReadyCallback callback,
                        gpointer user_data);

EGdbusCallStartUint ()

void
(*EGdbusCallStartUint) (GDBusProxy *proxy,
                        guint in_uint,
                        GCancellable *cancellable,
                        GAsyncReadyCallback callback,
                        gpointer user_data);

EGdbusCallFinishVoid ()

gboolean
(*EGdbusCallFinishVoid) (GDBusProxy *proxy,
                         GAsyncResult *result,
                         GError **error);

EGdbusCallFinishBoolean ()

gboolean
(*EGdbusCallFinishBoolean) (GDBusProxy *proxy,
                            GAsyncResult *result,
                            gboolean *out_boolean,
                            GError **error);

EGdbusCallFinishString ()

gboolean
(*EGdbusCallFinishString) (GDBusProxy *proxy,
                           GAsyncResult *result,
                           gchar **out_string,
                           GError **error);

EGdbusCallFinishStrv ()

gboolean
(*EGdbusCallFinishStrv) (GDBusProxy *proxy,
                         GAsyncResult *result,
                         gchar ***out_strv,
                         GError **error);

EGdbusCallFinishUint ()

gboolean
(*EGdbusCallFinishUint) (GDBusProxy *proxy,
                         GAsyncResult *result,
                         guint *out_uint,
                         GError **error);

e_gdbus_proxy_call_sync_void__void ()

gboolean
e_gdbus_proxy_call_sync_void__void (GDBusProxy *proxy,
                                    GCancellable *cancellable,
                                    GError **error,
                                    EGdbusCallStartVoid start_func,
                                    EGdbusCallFinishVoid finish_func);

e_gdbus_proxy_call_sync_void__boolean ()

gboolean
e_gdbus_proxy_call_sync_void__boolean (GDBusProxy *proxy,
                                       gboolean *out_boolean,
                                       GCancellable *cancellable,
                                       GError **error,
                                       EGdbusCallStartVoid start_func,
                                       EGdbusCallFinishBoolean finish_func);

e_gdbus_proxy_call_sync_void__string ()

gboolean
e_gdbus_proxy_call_sync_void__string (GDBusProxy *proxy,
                                      gchar **out_string,
                                      GCancellable *cancellable,
                                      GError **error,
                                      EGdbusCallStartVoid start_func,
                                      EGdbusCallFinishString finish_func);

e_gdbus_proxy_call_sync_void__strv ()

gboolean
e_gdbus_proxy_call_sync_void__strv (GDBusProxy *proxy,
                                    gchar ***out_strv,
                                    GCancellable *cancellable,
                                    GError **error,
                                    EGdbusCallStartVoid start_func,
                                    EGdbusCallFinishStrv finish_func);

e_gdbus_proxy_call_sync_void__uint ()

gboolean
e_gdbus_proxy_call_sync_void__uint (GDBusProxy *proxy,
                                    guint *out_uint,
                                    GCancellable *cancellable,
                                    GError **error,
                                    EGdbusCallStartVoid start_func,
                                    EGdbusCallFinishUint finish_func);

e_gdbus_proxy_call_sync_boolean__void ()

gboolean
e_gdbus_proxy_call_sync_boolean__void (GDBusProxy *proxy,
                                       gboolean in_boolean,
                                       GCancellable *cancellable,
                                       GError **error,
                                       EGdbusCallStartBoolean start_func,
                                       EGdbusCallFinishVoid finish_func);

e_gdbus_proxy_call_sync_string__void ()

gboolean
e_gdbus_proxy_call_sync_string__void (GDBusProxy *proxy,
                                      const gchar *in_string,
                                      GCancellable *cancellable,
                                      GError **error,
                                      EGdbusCallStartString start_func,
                                      EGdbusCallFinishVoid finish_func);

e_gdbus_proxy_call_sync_strv__void ()

gboolean
e_gdbus_proxy_call_sync_strv__void (GDBusProxy *proxy,
                                    const gchar * const *in_strv,
                                    GCancellable *cancellable,
                                    GError **error,
                                    EGdbusCallStartStrv start_func,
                                    EGdbusCallFinishVoid finish_func);

e_gdbus_proxy_call_sync_uint__void ()

gboolean
e_gdbus_proxy_call_sync_uint__void (GDBusProxy *proxy,
                                    guint in_uint,
                                    GCancellable *cancellable,
                                    GError **error,
                                    EGdbusCallStartUint start_func,
                                    EGdbusCallFinishVoid finish_func);

e_gdbus_proxy_call_sync_string__string ()

gboolean
e_gdbus_proxy_call_sync_string__string
                               (GDBusProxy *proxy,
                                const gchar *in_string,
                                gchar **out_string,
                                GCancellable *cancellable,
                                GError **error,
                                EGdbusCallStartString start_func,
                                EGdbusCallFinishString finish_func);

e_gdbus_proxy_call_sync_string__strv ()

gboolean
e_gdbus_proxy_call_sync_string__strv (GDBusProxy *proxy,
                                      const gchar *in_string,
                                      gchar ***out_strv,
                                      GCancellable *cancellable,
                                      GError **error,
                                      EGdbusCallStartString start_func,
                                      EGdbusCallFinishStrv finish_func);

e_gdbus_proxy_call_sync_strv__string ()

gboolean
e_gdbus_proxy_call_sync_strv__string (GDBusProxy *proxy,
                                      const gchar * const *in_strv,
                                      gchar **out_string,
                                      GCancellable *cancellable,
                                      GError **error,
                                      EGdbusCallStartStrv start_func,
                                      EGdbusCallFinishString finish_func);

e_gdbus_proxy_call_sync_strv__strv ()

gboolean
e_gdbus_proxy_call_sync_strv__strv (GDBusProxy *proxy,
                                    const gchar * const *in_strv,
                                    gchar ***out_strv,
                                    GCancellable *cancellable,
                                    GError **error,
                                    EGdbusCallStartStrv start_func,
                                    EGdbusCallFinishStrv finish_func);

e_gdbus_proxy_method_call_void ()

void
e_gdbus_proxy_method_call_void (const gchar *method_name,
                                GDBusProxy *proxy,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

e_gdbus_proxy_method_call_boolean ()

void
e_gdbus_proxy_method_call_boolean (const gchar *method_name,
                                   GDBusProxy *proxy,
                                   gboolean in_boolean,
                                   GCancellable *cancellable,
                                   GAsyncReadyCallback callback,
                                   gpointer user_data);

e_gdbus_proxy_method_call_string ()

void
e_gdbus_proxy_method_call_string (const gchar *method_name,
                                  GDBusProxy *proxy,
                                  const gchar *in_string,
                                  GCancellable *cancellable,
                                  GAsyncReadyCallback callback,
                                  gpointer user_data);

e_gdbus_proxy_method_call_strv ()

void
e_gdbus_proxy_method_call_strv (const gchar *method_name,
                                GDBusProxy *proxy,
                                const gchar * const *in_strv,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

e_gdbus_proxy_method_call_uint ()

void
e_gdbus_proxy_method_call_uint (const gchar *method_name,
                                GDBusProxy *proxy,
                                guint in_uint,
                                GCancellable *cancellable,
                                GAsyncReadyCallback callback,
                                gpointer user_data);

e_gdbus_proxy_method_call_finish_void ()

gboolean
e_gdbus_proxy_method_call_finish_void (GDBusProxy *proxy,
                                       GAsyncResult *result,
                                       GError **error);

e_gdbus_proxy_method_call_finish_boolean ()

gboolean
e_gdbus_proxy_method_call_finish_boolean
                               (GDBusProxy *proxy,
                                GAsyncResult *result,
                                gboolean *out_boolean,
                                GError **error);

e_gdbus_proxy_method_call_finish_string ()

gboolean
e_gdbus_proxy_method_call_finish_string
                               (GDBusProxy *proxy,
                                GAsyncResult *result,
                                gchar **out_string,
                                GError **error);

e_gdbus_proxy_method_call_finish_strv ()

gboolean
e_gdbus_proxy_method_call_finish_strv (GDBusProxy *proxy,
                                       GAsyncResult *result,
                                       gchar ***out_strv,
                                       GError **error);

e_gdbus_proxy_method_call_finish_uint ()

gboolean
e_gdbus_proxy_method_call_finish_uint (GDBusProxy *proxy,
                                       GAsyncResult *result,
                                       guint *out_uint,
                                       GError **error);

e_gdbus_proxy_method_call_sync_void__void ()

gboolean
e_gdbus_proxy_method_call_sync_void__void
                               (const gchar *method_name,
                                GDBusProxy *proxy,
                                GCancellable *cancellable,
                                GError **error);

e_gdbus_proxy_method_call_sync_boolean__void ()

gboolean
e_gdbus_proxy_method_call_sync_boolean__void
                               (const gchar *method_name,
                                GDBusProxy *proxy,
                                gboolean in_boolean,
                                GCancellable *cancellable,
                                GError **error);

e_gdbus_proxy_method_call_sync_string__void ()

gboolean
e_gdbus_proxy_method_call_sync_string__void
                               (const gchar *method_name,
                                GDBusProxy *proxy,
                                const gchar *in_string,
                                GCancellable *cancellable,
                                GError **error);

e_gdbus_proxy_method_call_sync_strv__void ()

gboolean
e_gdbus_proxy_method_call_sync_strv__void
                               (const gchar *method_name,
                                GDBusProxy *proxy,
                                const gchar * const *in_strv,
                                GCancellable *cancellable,
                                GError **error);

e_gdbus_proxy_method_call_sync_uint__void ()

gboolean
e_gdbus_proxy_method_call_sync_uint__void
                               (const gchar *method_name,
                                GDBusProxy *proxy,
                                guint in_uint,
                                GCancellable *cancellable,
                                GError **error);

e_gdbus_proxy_method_call_sync_string__string ()

gboolean
e_gdbus_proxy_method_call_sync_string__string
                               (const gchar *method_name,
                                GDBusProxy *proxy,
                                const gchar *in_string,
                                gchar **out_string,
                                GCancellable *cancellable,
                                GError **error);

e_gdbus_proxy_method_call_sync_strv__string ()

gboolean
e_gdbus_proxy_method_call_sync_strv__string
                               (const gchar *method_name,
                                GDBusProxy *proxy,
                                const gchar * const *in_strv,
                                gchar **out_string,
                                GCancellable *cancellable,
                                GError **error);

e_gdbus_templates_encode_error ()

gchar **
e_gdbus_templates_encode_error (const GError *in_error);

e_gdbus_templates_decode_error ()

gboolean
e_gdbus_templates_decode_error (const gchar * const *in_strv,
                                GError **out_error);

e_gdbus_templates_encode_two_strings ()

gchar **
e_gdbus_templates_encode_two_strings (const gchar *in_str1,
                                      const gchar *in_str2);

e_gdbus_templates_decode_two_strings ()

gboolean
e_gdbus_templates_decode_two_strings (const gchar * const *in_strv,
                                      gchar **out_str1,
                                      gchar **out_str2);

struct EGdbusAsyncOpKeeperInterface

struct EGdbusAsyncOpKeeperInterface {
	GTypeInterface parent_iface;

	GHashTable * (* get_pending_ops) (EGdbusAsyncOpKeeper *object);
	gboolean (* cancel_op_sync) (EGdbusAsyncOpKeeper *object, guint in_opid, GCancellable *cancellable, GError **error);
};