/*
 * This file is generated by gdbus-codegen, do not modify it.
 *
 * The license of this code is the same as for the D-Bus interface description
 * it was derived from. Note that it links to GLib, so must comply with the
 * LGPL linking clauses.
 */

#ifndef __XDP_IMPL_DBUS_H__
#define __XDP_IMPL_DBUS_H__

#include <gio/gio.h>

G_BEGIN_DECLS


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Access */

#define XDP_DBUS_IMPL_TYPE_ACCESS (xdp_dbus_impl_access_get_type ())
#define XDP_DBUS_IMPL_ACCESS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_ACCESS, XdpDbusImplAccess))
#define XDP_DBUS_IMPL_IS_ACCESS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_ACCESS))
#define XDP_DBUS_IMPL_ACCESS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_ACCESS, XdpDbusImplAccessIface))

struct _XdpDbusImplAccess;
typedef struct _XdpDbusImplAccess XdpDbusImplAccess;
typedef struct _XdpDbusImplAccessIface XdpDbusImplAccessIface;

struct _XdpDbusImplAccessIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_access_dialog) (
    XdpDbusImplAccess *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    const gchar *arg_subtitle,
    const gchar *arg_body,
    GVariant *arg_options);

};

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

GType xdp_dbus_impl_access_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_access_interface_info (void);
guint xdp_dbus_impl_access_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_access_complete_access_dialog (
    XdpDbusImplAccess *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);



/* D-Bus method calls: */
void xdp_dbus_impl_access_call_access_dialog (
    XdpDbusImplAccess *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    const gchar *arg_subtitle,
    const gchar *arg_body,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_access_call_access_dialog_finish (
    XdpDbusImplAccess *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_access_call_access_dialog_sync (
    XdpDbusImplAccess *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    const gchar *arg_subtitle,
    const gchar *arg_body,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_DBUS_IMPL_TYPE_ACCESS_PROXY (xdp_dbus_impl_access_proxy_get_type ())
#define XDP_DBUS_IMPL_ACCESS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_ACCESS_PROXY, XdpDbusImplAccessProxy))
#define XDP_DBUS_IMPL_ACCESS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_ACCESS_PROXY, XdpDbusImplAccessProxyClass))
#define XDP_DBUS_IMPL_ACCESS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_ACCESS_PROXY, XdpDbusImplAccessProxyClass))
#define XDP_DBUS_IMPL_IS_ACCESS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_ACCESS_PROXY))
#define XDP_DBUS_IMPL_IS_ACCESS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_ACCESS_PROXY))

typedef struct _XdpDbusImplAccessProxy XdpDbusImplAccessProxy;
typedef struct _XdpDbusImplAccessProxyClass XdpDbusImplAccessProxyClass;
typedef struct _XdpDbusImplAccessProxyPrivate XdpDbusImplAccessProxyPrivate;

struct _XdpDbusImplAccessProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplAccessProxyPrivate *priv;
};

struct _XdpDbusImplAccessProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_access_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_access_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplAccess *xdp_dbus_impl_access_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplAccess *xdp_dbus_impl_access_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_access_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplAccess *xdp_dbus_impl_access_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplAccess *xdp_dbus_impl_access_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_ACCESS_SKELETON (xdp_dbus_impl_access_skeleton_get_type ())
#define XDP_DBUS_IMPL_ACCESS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_ACCESS_SKELETON, XdpDbusImplAccessSkeleton))
#define XDP_DBUS_IMPL_ACCESS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_ACCESS_SKELETON, XdpDbusImplAccessSkeletonClass))
#define XDP_DBUS_IMPL_ACCESS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_ACCESS_SKELETON, XdpDbusImplAccessSkeletonClass))
#define XDP_DBUS_IMPL_IS_ACCESS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_ACCESS_SKELETON))
#define XDP_DBUS_IMPL_IS_ACCESS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_ACCESS_SKELETON))

typedef struct _XdpDbusImplAccessSkeleton XdpDbusImplAccessSkeleton;
typedef struct _XdpDbusImplAccessSkeletonClass XdpDbusImplAccessSkeletonClass;
typedef struct _XdpDbusImplAccessSkeletonPrivate XdpDbusImplAccessSkeletonPrivate;

struct _XdpDbusImplAccessSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplAccessSkeletonPrivate *priv;
};

struct _XdpDbusImplAccessSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_access_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplAccess *xdp_dbus_impl_access_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Account */

#define XDP_DBUS_IMPL_TYPE_ACCOUNT (xdp_dbus_impl_account_get_type ())
#define XDP_DBUS_IMPL_ACCOUNT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_ACCOUNT, XdpDbusImplAccount))
#define XDP_DBUS_IMPL_IS_ACCOUNT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_ACCOUNT))
#define XDP_DBUS_IMPL_ACCOUNT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_ACCOUNT, XdpDbusImplAccountIface))

struct _XdpDbusImplAccount;
typedef struct _XdpDbusImplAccount XdpDbusImplAccount;
typedef struct _XdpDbusImplAccountIface XdpDbusImplAccountIface;

struct _XdpDbusImplAccountIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_get_user_information) (
    XdpDbusImplAccount *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_window,
    GVariant *arg_options);

};

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

GType xdp_dbus_impl_account_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_account_interface_info (void);
guint xdp_dbus_impl_account_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_account_complete_get_user_information (
    XdpDbusImplAccount *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);



/* D-Bus method calls: */
void xdp_dbus_impl_account_call_get_user_information (
    XdpDbusImplAccount *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_account_call_get_user_information_finish (
    XdpDbusImplAccount *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_account_call_get_user_information_sync (
    XdpDbusImplAccount *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_window,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_DBUS_IMPL_TYPE_ACCOUNT_PROXY (xdp_dbus_impl_account_proxy_get_type ())
#define XDP_DBUS_IMPL_ACCOUNT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_ACCOUNT_PROXY, XdpDbusImplAccountProxy))
#define XDP_DBUS_IMPL_ACCOUNT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_ACCOUNT_PROXY, XdpDbusImplAccountProxyClass))
#define XDP_DBUS_IMPL_ACCOUNT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_ACCOUNT_PROXY, XdpDbusImplAccountProxyClass))
#define XDP_DBUS_IMPL_IS_ACCOUNT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_ACCOUNT_PROXY))
#define XDP_DBUS_IMPL_IS_ACCOUNT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_ACCOUNT_PROXY))

typedef struct _XdpDbusImplAccountProxy XdpDbusImplAccountProxy;
typedef struct _XdpDbusImplAccountProxyClass XdpDbusImplAccountProxyClass;
typedef struct _XdpDbusImplAccountProxyPrivate XdpDbusImplAccountProxyPrivate;

struct _XdpDbusImplAccountProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplAccountProxyPrivate *priv;
};

struct _XdpDbusImplAccountProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_account_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_account_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplAccount *xdp_dbus_impl_account_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplAccount *xdp_dbus_impl_account_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_account_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplAccount *xdp_dbus_impl_account_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplAccount *xdp_dbus_impl_account_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_ACCOUNT_SKELETON (xdp_dbus_impl_account_skeleton_get_type ())
#define XDP_DBUS_IMPL_ACCOUNT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_ACCOUNT_SKELETON, XdpDbusImplAccountSkeleton))
#define XDP_DBUS_IMPL_ACCOUNT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_ACCOUNT_SKELETON, XdpDbusImplAccountSkeletonClass))
#define XDP_DBUS_IMPL_ACCOUNT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_ACCOUNT_SKELETON, XdpDbusImplAccountSkeletonClass))
#define XDP_DBUS_IMPL_IS_ACCOUNT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_ACCOUNT_SKELETON))
#define XDP_DBUS_IMPL_IS_ACCOUNT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_ACCOUNT_SKELETON))

typedef struct _XdpDbusImplAccountSkeleton XdpDbusImplAccountSkeleton;
typedef struct _XdpDbusImplAccountSkeletonClass XdpDbusImplAccountSkeletonClass;
typedef struct _XdpDbusImplAccountSkeletonPrivate XdpDbusImplAccountSkeletonPrivate;

struct _XdpDbusImplAccountSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplAccountSkeletonPrivate *priv;
};

struct _XdpDbusImplAccountSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_account_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplAccount *xdp_dbus_impl_account_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.AppChooser */

#define XDP_DBUS_IMPL_TYPE_APP_CHOOSER (xdp_dbus_impl_app_chooser_get_type ())
#define XDP_DBUS_IMPL_APP_CHOOSER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_APP_CHOOSER, XdpDbusImplAppChooser))
#define XDP_DBUS_IMPL_IS_APP_CHOOSER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_APP_CHOOSER))
#define XDP_DBUS_IMPL_APP_CHOOSER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_APP_CHOOSER, XdpDbusImplAppChooserIface))

struct _XdpDbusImplAppChooser;
typedef struct _XdpDbusImplAppChooser XdpDbusImplAppChooser;
typedef struct _XdpDbusImplAppChooserIface XdpDbusImplAppChooserIface;

struct _XdpDbusImplAppChooserIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_choose_application) (
    XdpDbusImplAppChooser *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *const *arg_choices,
    GVariant *arg_options);

  gboolean (*handle_update_choices) (
    XdpDbusImplAppChooser *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *const *arg_choices);

};

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

GType xdp_dbus_impl_app_chooser_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_app_chooser_interface_info (void);
guint xdp_dbus_impl_app_chooser_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_app_chooser_complete_choose_application (
    XdpDbusImplAppChooser *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_app_chooser_complete_update_choices (
    XdpDbusImplAppChooser *object,
    GDBusMethodInvocation *invocation);



/* D-Bus method calls: */
void xdp_dbus_impl_app_chooser_call_choose_application (
    XdpDbusImplAppChooser *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *const *arg_choices,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_app_chooser_call_choose_application_finish (
    XdpDbusImplAppChooser *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_app_chooser_call_choose_application_sync (
    XdpDbusImplAppChooser *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *const *arg_choices,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_app_chooser_call_update_choices (
    XdpDbusImplAppChooser *proxy,
    const gchar *arg_handle,
    const gchar *const *arg_choices,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_app_chooser_call_update_choices_finish (
    XdpDbusImplAppChooser *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_app_chooser_call_update_choices_sync (
    XdpDbusImplAppChooser *proxy,
    const gchar *arg_handle,
    const gchar *const *arg_choices,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_DBUS_IMPL_TYPE_APP_CHOOSER_PROXY (xdp_dbus_impl_app_chooser_proxy_get_type ())
#define XDP_DBUS_IMPL_APP_CHOOSER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_APP_CHOOSER_PROXY, XdpDbusImplAppChooserProxy))
#define XDP_DBUS_IMPL_APP_CHOOSER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_APP_CHOOSER_PROXY, XdpDbusImplAppChooserProxyClass))
#define XDP_DBUS_IMPL_APP_CHOOSER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_APP_CHOOSER_PROXY, XdpDbusImplAppChooserProxyClass))
#define XDP_DBUS_IMPL_IS_APP_CHOOSER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_APP_CHOOSER_PROXY))
#define XDP_DBUS_IMPL_IS_APP_CHOOSER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_APP_CHOOSER_PROXY))

typedef struct _XdpDbusImplAppChooserProxy XdpDbusImplAppChooserProxy;
typedef struct _XdpDbusImplAppChooserProxyClass XdpDbusImplAppChooserProxyClass;
typedef struct _XdpDbusImplAppChooserProxyPrivate XdpDbusImplAppChooserProxyPrivate;

struct _XdpDbusImplAppChooserProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplAppChooserProxyPrivate *priv;
};

struct _XdpDbusImplAppChooserProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_app_chooser_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_app_chooser_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplAppChooser *xdp_dbus_impl_app_chooser_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplAppChooser *xdp_dbus_impl_app_chooser_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_app_chooser_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplAppChooser *xdp_dbus_impl_app_chooser_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplAppChooser *xdp_dbus_impl_app_chooser_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_APP_CHOOSER_SKELETON (xdp_dbus_impl_app_chooser_skeleton_get_type ())
#define XDP_DBUS_IMPL_APP_CHOOSER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_APP_CHOOSER_SKELETON, XdpDbusImplAppChooserSkeleton))
#define XDP_DBUS_IMPL_APP_CHOOSER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_APP_CHOOSER_SKELETON, XdpDbusImplAppChooserSkeletonClass))
#define XDP_DBUS_IMPL_APP_CHOOSER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_APP_CHOOSER_SKELETON, XdpDbusImplAppChooserSkeletonClass))
#define XDP_DBUS_IMPL_IS_APP_CHOOSER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_APP_CHOOSER_SKELETON))
#define XDP_DBUS_IMPL_IS_APP_CHOOSER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_APP_CHOOSER_SKELETON))

typedef struct _XdpDbusImplAppChooserSkeleton XdpDbusImplAppChooserSkeleton;
typedef struct _XdpDbusImplAppChooserSkeletonClass XdpDbusImplAppChooserSkeletonClass;
typedef struct _XdpDbusImplAppChooserSkeletonPrivate XdpDbusImplAppChooserSkeletonPrivate;

struct _XdpDbusImplAppChooserSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplAppChooserSkeletonPrivate *priv;
};

struct _XdpDbusImplAppChooserSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_app_chooser_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplAppChooser *xdp_dbus_impl_app_chooser_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Background */

#define XDP_DBUS_IMPL_TYPE_BACKGROUND (xdp_dbus_impl_background_get_type ())
#define XDP_DBUS_IMPL_BACKGROUND(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_BACKGROUND, XdpDbusImplBackground))
#define XDP_DBUS_IMPL_IS_BACKGROUND(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_BACKGROUND))
#define XDP_DBUS_IMPL_BACKGROUND_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_BACKGROUND, XdpDbusImplBackgroundIface))

struct _XdpDbusImplBackground;
typedef struct _XdpDbusImplBackground XdpDbusImplBackground;
typedef struct _XdpDbusImplBackgroundIface XdpDbusImplBackgroundIface;

struct _XdpDbusImplBackgroundIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_enable_autostart) (
    XdpDbusImplBackground *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_app_id,
    gboolean arg_enable,
    const gchar *const *arg_commandline,
    guint arg_flags);

  gboolean (*handle_get_app_state) (
    XdpDbusImplBackground *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_notify_background) (
    XdpDbusImplBackground *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_name);

  void (*running_applications_changed) (
    XdpDbusImplBackground *object);

};

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

GType xdp_dbus_impl_background_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_background_interface_info (void);
guint xdp_dbus_impl_background_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_background_complete_get_app_state (
    XdpDbusImplBackground *object,
    GDBusMethodInvocation *invocation,
    GVariant *apps);

void xdp_dbus_impl_background_complete_notify_background (
    XdpDbusImplBackground *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_background_complete_enable_autostart (
    XdpDbusImplBackground *object,
    GDBusMethodInvocation *invocation,
    gboolean result);



/* D-Bus signal emissions functions: */
void xdp_dbus_impl_background_emit_running_applications_changed (
    XdpDbusImplBackground *object);



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

gboolean xdp_dbus_impl_background_call_get_app_state_finish (
    XdpDbusImplBackground *proxy,
    GVariant ** out_apps,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_background_call_get_app_state_sync (
    XdpDbusImplBackground *proxy,
    GVariant ** out_apps,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_background_call_notify_background (
    XdpDbusImplBackground *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_name,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_background_call_notify_background_finish (
    XdpDbusImplBackground *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_background_call_notify_background_sync (
    XdpDbusImplBackground *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_name,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_background_call_enable_autostart (
    XdpDbusImplBackground *proxy,
    const gchar *arg_app_id,
    gboolean arg_enable,
    const gchar *const *arg_commandline,
    guint arg_flags,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_background_call_enable_autostart_finish (
    XdpDbusImplBackground *proxy,
    gboolean* out_result,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_background_call_enable_autostart_sync (
    XdpDbusImplBackground *proxy,
    const gchar *arg_app_id,
    gboolean arg_enable,
    const gchar *const *arg_commandline,
    guint arg_flags,
    gboolean* out_result,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_DBUS_IMPL_TYPE_BACKGROUND_PROXY (xdp_dbus_impl_background_proxy_get_type ())
#define XDP_DBUS_IMPL_BACKGROUND_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_BACKGROUND_PROXY, XdpDbusImplBackgroundProxy))
#define XDP_DBUS_IMPL_BACKGROUND_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_BACKGROUND_PROXY, XdpDbusImplBackgroundProxyClass))
#define XDP_DBUS_IMPL_BACKGROUND_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_BACKGROUND_PROXY, XdpDbusImplBackgroundProxyClass))
#define XDP_DBUS_IMPL_IS_BACKGROUND_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_BACKGROUND_PROXY))
#define XDP_DBUS_IMPL_IS_BACKGROUND_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_BACKGROUND_PROXY))

typedef struct _XdpDbusImplBackgroundProxy XdpDbusImplBackgroundProxy;
typedef struct _XdpDbusImplBackgroundProxyClass XdpDbusImplBackgroundProxyClass;
typedef struct _XdpDbusImplBackgroundProxyPrivate XdpDbusImplBackgroundProxyPrivate;

struct _XdpDbusImplBackgroundProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplBackgroundProxyPrivate *priv;
};

struct _XdpDbusImplBackgroundProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_background_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_background_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplBackground *xdp_dbus_impl_background_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplBackground *xdp_dbus_impl_background_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_background_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplBackground *xdp_dbus_impl_background_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplBackground *xdp_dbus_impl_background_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_BACKGROUND_SKELETON (xdp_dbus_impl_background_skeleton_get_type ())
#define XDP_DBUS_IMPL_BACKGROUND_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_BACKGROUND_SKELETON, XdpDbusImplBackgroundSkeleton))
#define XDP_DBUS_IMPL_BACKGROUND_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_BACKGROUND_SKELETON, XdpDbusImplBackgroundSkeletonClass))
#define XDP_DBUS_IMPL_BACKGROUND_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_BACKGROUND_SKELETON, XdpDbusImplBackgroundSkeletonClass))
#define XDP_DBUS_IMPL_IS_BACKGROUND_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_BACKGROUND_SKELETON))
#define XDP_DBUS_IMPL_IS_BACKGROUND_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_BACKGROUND_SKELETON))

typedef struct _XdpDbusImplBackgroundSkeleton XdpDbusImplBackgroundSkeleton;
typedef struct _XdpDbusImplBackgroundSkeletonClass XdpDbusImplBackgroundSkeletonClass;
typedef struct _XdpDbusImplBackgroundSkeletonPrivate XdpDbusImplBackgroundSkeletonPrivate;

struct _XdpDbusImplBackgroundSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplBackgroundSkeletonPrivate *priv;
};

struct _XdpDbusImplBackgroundSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_background_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplBackground *xdp_dbus_impl_background_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Clipboard */

#define XDP_DBUS_IMPL_TYPE_CLIPBOARD (xdp_dbus_impl_clipboard_get_type ())
#define XDP_DBUS_IMPL_CLIPBOARD(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_CLIPBOARD, XdpDbusImplClipboard))
#define XDP_DBUS_IMPL_IS_CLIPBOARD(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_CLIPBOARD))
#define XDP_DBUS_IMPL_CLIPBOARD_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_CLIPBOARD, XdpDbusImplClipboardIface))

struct _XdpDbusImplClipboard;
typedef struct _XdpDbusImplClipboard XdpDbusImplClipboard;
typedef struct _XdpDbusImplClipboardIface XdpDbusImplClipboardIface;

struct _XdpDbusImplClipboardIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_request_clipboard) (
    XdpDbusImplClipboard *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options);

  gboolean (*handle_selection_read) (
    XdpDbusImplClipboard *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_session_handle,
    const gchar *arg_mime_type);

  gboolean (*handle_selection_write) (
    XdpDbusImplClipboard *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_session_handle,
    guint arg_serial);

  gboolean (*handle_selection_write_done) (
    XdpDbusImplClipboard *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    guint arg_serial,
    gboolean arg_success);

  gboolean (*handle_set_selection) (
    XdpDbusImplClipboard *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options);

  guint  (*get_version) (XdpDbusImplClipboard *object);

  void (*selection_owner_changed) (
    XdpDbusImplClipboard *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);

  void (*selection_transfer) (
    XdpDbusImplClipboard *object,
    const gchar *arg_session_handle,
    const gchar *arg_mime_type,
    guint arg_serial);

};

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

GType xdp_dbus_impl_clipboard_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_clipboard_interface_info (void);
guint xdp_dbus_impl_clipboard_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_dbus_impl_clipboard_complete_set_selection (
    XdpDbusImplClipboard *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_clipboard_complete_selection_write (
    XdpDbusImplClipboard *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);

void xdp_dbus_impl_clipboard_complete_selection_write_done (
    XdpDbusImplClipboard *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_clipboard_complete_selection_read (
    XdpDbusImplClipboard *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);



/* D-Bus signal emissions functions: */
void xdp_dbus_impl_clipboard_emit_selection_owner_changed (
    XdpDbusImplClipboard *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);

void xdp_dbus_impl_clipboard_emit_selection_transfer (
    XdpDbusImplClipboard *object,
    const gchar *arg_session_handle,
    const gchar *arg_mime_type,
    guint arg_serial);



/* D-Bus method calls: */
void xdp_dbus_impl_clipboard_call_request_clipboard (
    XdpDbusImplClipboard *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_clipboard_call_request_clipboard_finish (
    XdpDbusImplClipboard *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_clipboard_call_request_clipboard_sync (
    XdpDbusImplClipboard *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_clipboard_call_set_selection (
    XdpDbusImplClipboard *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_clipboard_call_set_selection_finish (
    XdpDbusImplClipboard *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_clipboard_call_set_selection_sync (
    XdpDbusImplClipboard *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_clipboard_call_selection_write (
    XdpDbusImplClipboard *proxy,
    const gchar *arg_session_handle,
    guint arg_serial,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_clipboard_call_selection_write_finish (
    XdpDbusImplClipboard *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_clipboard_call_selection_write_sync (
    XdpDbusImplClipboard *proxy,
    const gchar *arg_session_handle,
    guint arg_serial,
    GUnixFDList  *fd_list,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_clipboard_call_selection_write_done (
    XdpDbusImplClipboard *proxy,
    const gchar *arg_session_handle,
    guint arg_serial,
    gboolean arg_success,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_clipboard_call_selection_write_done_finish (
    XdpDbusImplClipboard *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_clipboard_call_selection_write_done_sync (
    XdpDbusImplClipboard *proxy,
    const gchar *arg_session_handle,
    guint arg_serial,
    gboolean arg_success,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_clipboard_call_selection_read (
    XdpDbusImplClipboard *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_mime_type,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_clipboard_call_selection_read_finish (
    XdpDbusImplClipboard *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_clipboard_call_selection_read_sync (
    XdpDbusImplClipboard *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_mime_type,
    GUnixFDList  *fd_list,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_impl_clipboard_get_version (XdpDbusImplClipboard *object);
void xdp_dbus_impl_clipboard_set_version (XdpDbusImplClipboard *object, guint value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_CLIPBOARD_PROXY (xdp_dbus_impl_clipboard_proxy_get_type ())
#define XDP_DBUS_IMPL_CLIPBOARD_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_CLIPBOARD_PROXY, XdpDbusImplClipboardProxy))
#define XDP_DBUS_IMPL_CLIPBOARD_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_CLIPBOARD_PROXY, XdpDbusImplClipboardProxyClass))
#define XDP_DBUS_IMPL_CLIPBOARD_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_CLIPBOARD_PROXY, XdpDbusImplClipboardProxyClass))
#define XDP_DBUS_IMPL_IS_CLIPBOARD_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_CLIPBOARD_PROXY))
#define XDP_DBUS_IMPL_IS_CLIPBOARD_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_CLIPBOARD_PROXY))

typedef struct _XdpDbusImplClipboardProxy XdpDbusImplClipboardProxy;
typedef struct _XdpDbusImplClipboardProxyClass XdpDbusImplClipboardProxyClass;
typedef struct _XdpDbusImplClipboardProxyPrivate XdpDbusImplClipboardProxyPrivate;

struct _XdpDbusImplClipboardProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplClipboardProxyPrivate *priv;
};

struct _XdpDbusImplClipboardProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_clipboard_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_clipboard_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplClipboard *xdp_dbus_impl_clipboard_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplClipboard *xdp_dbus_impl_clipboard_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_clipboard_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplClipboard *xdp_dbus_impl_clipboard_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplClipboard *xdp_dbus_impl_clipboard_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_CLIPBOARD_SKELETON (xdp_dbus_impl_clipboard_skeleton_get_type ())
#define XDP_DBUS_IMPL_CLIPBOARD_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_CLIPBOARD_SKELETON, XdpDbusImplClipboardSkeleton))
#define XDP_DBUS_IMPL_CLIPBOARD_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_CLIPBOARD_SKELETON, XdpDbusImplClipboardSkeletonClass))
#define XDP_DBUS_IMPL_CLIPBOARD_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_CLIPBOARD_SKELETON, XdpDbusImplClipboardSkeletonClass))
#define XDP_DBUS_IMPL_IS_CLIPBOARD_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_CLIPBOARD_SKELETON))
#define XDP_DBUS_IMPL_IS_CLIPBOARD_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_CLIPBOARD_SKELETON))

typedef struct _XdpDbusImplClipboardSkeleton XdpDbusImplClipboardSkeleton;
typedef struct _XdpDbusImplClipboardSkeletonClass XdpDbusImplClipboardSkeletonClass;
typedef struct _XdpDbusImplClipboardSkeletonPrivate XdpDbusImplClipboardSkeletonPrivate;

struct _XdpDbusImplClipboardSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplClipboardSkeletonPrivate *priv;
};

struct _XdpDbusImplClipboardSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_clipboard_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplClipboard *xdp_dbus_impl_clipboard_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.DynamicLauncher */

#define XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER (xdp_dbus_impl_dynamic_launcher_get_type ())
#define XDP_DBUS_IMPL_DYNAMIC_LAUNCHER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER, XdpDbusImplDynamicLauncher))
#define XDP_DBUS_IMPL_IS_DYNAMIC_LAUNCHER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER))
#define XDP_DBUS_IMPL_DYNAMIC_LAUNCHER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER, XdpDbusImplDynamicLauncherIface))

struct _XdpDbusImplDynamicLauncher;
typedef struct _XdpDbusImplDynamicLauncher XdpDbusImplDynamicLauncher;
typedef struct _XdpDbusImplDynamicLauncherIface XdpDbusImplDynamicLauncherIface;

struct _XdpDbusImplDynamicLauncherIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_prepare_install) (
    XdpDbusImplDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_name,
    GVariant *arg_icon_v,
    GVariant *arg_options);

  gboolean (*handle_request_install_token) (
    XdpDbusImplDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_app_id,
    GVariant *arg_options);

  guint  (*get_supported_launcher_types) (XdpDbusImplDynamicLauncher *object);

  guint  (*get_version) (XdpDbusImplDynamicLauncher *object);

};

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

GType xdp_dbus_impl_dynamic_launcher_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_dynamic_launcher_interface_info (void);
guint xdp_dbus_impl_dynamic_launcher_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_dynamic_launcher_complete_prepare_install (
    XdpDbusImplDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_dynamic_launcher_complete_request_install_token (
    XdpDbusImplDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    guint response);



/* D-Bus method calls: */
void xdp_dbus_impl_dynamic_launcher_call_prepare_install (
    XdpDbusImplDynamicLauncher *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_name,
    GVariant *arg_icon_v,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_dynamic_launcher_call_prepare_install_finish (
    XdpDbusImplDynamicLauncher *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_dynamic_launcher_call_prepare_install_sync (
    XdpDbusImplDynamicLauncher *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_name,
    GVariant *arg_icon_v,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_dynamic_launcher_call_request_install_token (
    XdpDbusImplDynamicLauncher *proxy,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_dynamic_launcher_call_request_install_token_finish (
    XdpDbusImplDynamicLauncher *proxy,
    guint* out_response,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_dynamic_launcher_call_request_install_token_sync (
    XdpDbusImplDynamicLauncher *proxy,
    const gchar *arg_app_id,
    GVariant *arg_options,
    guint* out_response,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_impl_dynamic_launcher_get_supported_launcher_types (XdpDbusImplDynamicLauncher *object);
void xdp_dbus_impl_dynamic_launcher_set_supported_launcher_types (XdpDbusImplDynamicLauncher *object, guint value);

guint xdp_dbus_impl_dynamic_launcher_get_version (XdpDbusImplDynamicLauncher *object);
void xdp_dbus_impl_dynamic_launcher_set_version (XdpDbusImplDynamicLauncher *object, guint value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER_PROXY (xdp_dbus_impl_dynamic_launcher_proxy_get_type ())
#define XDP_DBUS_IMPL_DYNAMIC_LAUNCHER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER_PROXY, XdpDbusImplDynamicLauncherProxy))
#define XDP_DBUS_IMPL_DYNAMIC_LAUNCHER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER_PROXY, XdpDbusImplDynamicLauncherProxyClass))
#define XDP_DBUS_IMPL_DYNAMIC_LAUNCHER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER_PROXY, XdpDbusImplDynamicLauncherProxyClass))
#define XDP_DBUS_IMPL_IS_DYNAMIC_LAUNCHER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER_PROXY))
#define XDP_DBUS_IMPL_IS_DYNAMIC_LAUNCHER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER_PROXY))

typedef struct _XdpDbusImplDynamicLauncherProxy XdpDbusImplDynamicLauncherProxy;
typedef struct _XdpDbusImplDynamicLauncherProxyClass XdpDbusImplDynamicLauncherProxyClass;
typedef struct _XdpDbusImplDynamicLauncherProxyPrivate XdpDbusImplDynamicLauncherProxyPrivate;

struct _XdpDbusImplDynamicLauncherProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplDynamicLauncherProxyPrivate *priv;
};

struct _XdpDbusImplDynamicLauncherProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_dynamic_launcher_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_dynamic_launcher_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplDynamicLauncher *xdp_dbus_impl_dynamic_launcher_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplDynamicLauncher *xdp_dbus_impl_dynamic_launcher_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_dynamic_launcher_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplDynamicLauncher *xdp_dbus_impl_dynamic_launcher_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplDynamicLauncher *xdp_dbus_impl_dynamic_launcher_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER_SKELETON (xdp_dbus_impl_dynamic_launcher_skeleton_get_type ())
#define XDP_DBUS_IMPL_DYNAMIC_LAUNCHER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER_SKELETON, XdpDbusImplDynamicLauncherSkeleton))
#define XDP_DBUS_IMPL_DYNAMIC_LAUNCHER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER_SKELETON, XdpDbusImplDynamicLauncherSkeletonClass))
#define XDP_DBUS_IMPL_DYNAMIC_LAUNCHER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER_SKELETON, XdpDbusImplDynamicLauncherSkeletonClass))
#define XDP_DBUS_IMPL_IS_DYNAMIC_LAUNCHER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER_SKELETON))
#define XDP_DBUS_IMPL_IS_DYNAMIC_LAUNCHER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_DYNAMIC_LAUNCHER_SKELETON))

typedef struct _XdpDbusImplDynamicLauncherSkeleton XdpDbusImplDynamicLauncherSkeleton;
typedef struct _XdpDbusImplDynamicLauncherSkeletonClass XdpDbusImplDynamicLauncherSkeletonClass;
typedef struct _XdpDbusImplDynamicLauncherSkeletonPrivate XdpDbusImplDynamicLauncherSkeletonPrivate;

struct _XdpDbusImplDynamicLauncherSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplDynamicLauncherSkeletonPrivate *priv;
};

struct _XdpDbusImplDynamicLauncherSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_dynamic_launcher_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplDynamicLauncher *xdp_dbus_impl_dynamic_launcher_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Email */

#define XDP_DBUS_IMPL_TYPE_EMAIL (xdp_dbus_impl_email_get_type ())
#define XDP_DBUS_IMPL_EMAIL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_EMAIL, XdpDbusImplEmail))
#define XDP_DBUS_IMPL_IS_EMAIL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_EMAIL))
#define XDP_DBUS_IMPL_EMAIL_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_EMAIL, XdpDbusImplEmailIface))

struct _XdpDbusImplEmail;
typedef struct _XdpDbusImplEmail XdpDbusImplEmail;
typedef struct _XdpDbusImplEmailIface XdpDbusImplEmailIface;

struct _XdpDbusImplEmailIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_compose_email) (
    XdpDbusImplEmail *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options);

};

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

GType xdp_dbus_impl_email_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_email_interface_info (void);
guint xdp_dbus_impl_email_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_email_complete_compose_email (
    XdpDbusImplEmail *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);



/* D-Bus method calls: */
void xdp_dbus_impl_email_call_compose_email (
    XdpDbusImplEmail *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_email_call_compose_email_finish (
    XdpDbusImplEmail *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_email_call_compose_email_sync (
    XdpDbusImplEmail *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_DBUS_IMPL_TYPE_EMAIL_PROXY (xdp_dbus_impl_email_proxy_get_type ())
#define XDP_DBUS_IMPL_EMAIL_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_EMAIL_PROXY, XdpDbusImplEmailProxy))
#define XDP_DBUS_IMPL_EMAIL_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_EMAIL_PROXY, XdpDbusImplEmailProxyClass))
#define XDP_DBUS_IMPL_EMAIL_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_EMAIL_PROXY, XdpDbusImplEmailProxyClass))
#define XDP_DBUS_IMPL_IS_EMAIL_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_EMAIL_PROXY))
#define XDP_DBUS_IMPL_IS_EMAIL_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_EMAIL_PROXY))

typedef struct _XdpDbusImplEmailProxy XdpDbusImplEmailProxy;
typedef struct _XdpDbusImplEmailProxyClass XdpDbusImplEmailProxyClass;
typedef struct _XdpDbusImplEmailProxyPrivate XdpDbusImplEmailProxyPrivate;

struct _XdpDbusImplEmailProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplEmailProxyPrivate *priv;
};

struct _XdpDbusImplEmailProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_email_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_email_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplEmail *xdp_dbus_impl_email_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplEmail *xdp_dbus_impl_email_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_email_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplEmail *xdp_dbus_impl_email_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplEmail *xdp_dbus_impl_email_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_EMAIL_SKELETON (xdp_dbus_impl_email_skeleton_get_type ())
#define XDP_DBUS_IMPL_EMAIL_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_EMAIL_SKELETON, XdpDbusImplEmailSkeleton))
#define XDP_DBUS_IMPL_EMAIL_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_EMAIL_SKELETON, XdpDbusImplEmailSkeletonClass))
#define XDP_DBUS_IMPL_EMAIL_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_EMAIL_SKELETON, XdpDbusImplEmailSkeletonClass))
#define XDP_DBUS_IMPL_IS_EMAIL_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_EMAIL_SKELETON))
#define XDP_DBUS_IMPL_IS_EMAIL_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_EMAIL_SKELETON))

typedef struct _XdpDbusImplEmailSkeleton XdpDbusImplEmailSkeleton;
typedef struct _XdpDbusImplEmailSkeletonClass XdpDbusImplEmailSkeletonClass;
typedef struct _XdpDbusImplEmailSkeletonPrivate XdpDbusImplEmailSkeletonPrivate;

struct _XdpDbusImplEmailSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplEmailSkeletonPrivate *priv;
};

struct _XdpDbusImplEmailSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_email_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplEmail *xdp_dbus_impl_email_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.FileChooser */

#define XDP_DBUS_IMPL_TYPE_FILE_CHOOSER (xdp_dbus_impl_file_chooser_get_type ())
#define XDP_DBUS_IMPL_FILE_CHOOSER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_FILE_CHOOSER, XdpDbusImplFileChooser))
#define XDP_DBUS_IMPL_IS_FILE_CHOOSER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_FILE_CHOOSER))
#define XDP_DBUS_IMPL_FILE_CHOOSER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_FILE_CHOOSER, XdpDbusImplFileChooserIface))

struct _XdpDbusImplFileChooser;
typedef struct _XdpDbusImplFileChooser XdpDbusImplFileChooser;
typedef struct _XdpDbusImplFileChooserIface XdpDbusImplFileChooserIface;

struct _XdpDbusImplFileChooserIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_open_file) (
    XdpDbusImplFileChooser *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options);

  gboolean (*handle_save_file) (
    XdpDbusImplFileChooser *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options);

  gboolean (*handle_save_files) (
    XdpDbusImplFileChooser *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options);

};

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

GType xdp_dbus_impl_file_chooser_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_file_chooser_interface_info (void);
guint xdp_dbus_impl_file_chooser_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_file_chooser_complete_open_file (
    XdpDbusImplFileChooser *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_file_chooser_complete_save_file (
    XdpDbusImplFileChooser *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_file_chooser_complete_save_files (
    XdpDbusImplFileChooser *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);



/* D-Bus method calls: */
void xdp_dbus_impl_file_chooser_call_open_file (
    XdpDbusImplFileChooser *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_file_chooser_call_open_file_finish (
    XdpDbusImplFileChooser *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_file_chooser_call_open_file_sync (
    XdpDbusImplFileChooser *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_file_chooser_call_save_file (
    XdpDbusImplFileChooser *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_file_chooser_call_save_file_finish (
    XdpDbusImplFileChooser *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_file_chooser_call_save_file_sync (
    XdpDbusImplFileChooser *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_file_chooser_call_save_files (
    XdpDbusImplFileChooser *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_file_chooser_call_save_files_finish (
    XdpDbusImplFileChooser *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_file_chooser_call_save_files_sync (
    XdpDbusImplFileChooser *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_DBUS_IMPL_TYPE_FILE_CHOOSER_PROXY (xdp_dbus_impl_file_chooser_proxy_get_type ())
#define XDP_DBUS_IMPL_FILE_CHOOSER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_FILE_CHOOSER_PROXY, XdpDbusImplFileChooserProxy))
#define XDP_DBUS_IMPL_FILE_CHOOSER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_FILE_CHOOSER_PROXY, XdpDbusImplFileChooserProxyClass))
#define XDP_DBUS_IMPL_FILE_CHOOSER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_FILE_CHOOSER_PROXY, XdpDbusImplFileChooserProxyClass))
#define XDP_DBUS_IMPL_IS_FILE_CHOOSER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_FILE_CHOOSER_PROXY))
#define XDP_DBUS_IMPL_IS_FILE_CHOOSER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_FILE_CHOOSER_PROXY))

typedef struct _XdpDbusImplFileChooserProxy XdpDbusImplFileChooserProxy;
typedef struct _XdpDbusImplFileChooserProxyClass XdpDbusImplFileChooserProxyClass;
typedef struct _XdpDbusImplFileChooserProxyPrivate XdpDbusImplFileChooserProxyPrivate;

struct _XdpDbusImplFileChooserProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplFileChooserProxyPrivate *priv;
};

struct _XdpDbusImplFileChooserProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_file_chooser_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_file_chooser_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplFileChooser *xdp_dbus_impl_file_chooser_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplFileChooser *xdp_dbus_impl_file_chooser_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_file_chooser_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplFileChooser *xdp_dbus_impl_file_chooser_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplFileChooser *xdp_dbus_impl_file_chooser_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_FILE_CHOOSER_SKELETON (xdp_dbus_impl_file_chooser_skeleton_get_type ())
#define XDP_DBUS_IMPL_FILE_CHOOSER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_FILE_CHOOSER_SKELETON, XdpDbusImplFileChooserSkeleton))
#define XDP_DBUS_IMPL_FILE_CHOOSER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_FILE_CHOOSER_SKELETON, XdpDbusImplFileChooserSkeletonClass))
#define XDP_DBUS_IMPL_FILE_CHOOSER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_FILE_CHOOSER_SKELETON, XdpDbusImplFileChooserSkeletonClass))
#define XDP_DBUS_IMPL_IS_FILE_CHOOSER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_FILE_CHOOSER_SKELETON))
#define XDP_DBUS_IMPL_IS_FILE_CHOOSER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_FILE_CHOOSER_SKELETON))

typedef struct _XdpDbusImplFileChooserSkeleton XdpDbusImplFileChooserSkeleton;
typedef struct _XdpDbusImplFileChooserSkeletonClass XdpDbusImplFileChooserSkeletonClass;
typedef struct _XdpDbusImplFileChooserSkeletonPrivate XdpDbusImplFileChooserSkeletonPrivate;

struct _XdpDbusImplFileChooserSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplFileChooserSkeletonPrivate *priv;
};

struct _XdpDbusImplFileChooserSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_file_chooser_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplFileChooser *xdp_dbus_impl_file_chooser_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.GlobalShortcuts */

#define XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS (xdp_dbus_impl_global_shortcuts_get_type ())
#define XDP_DBUS_IMPL_GLOBAL_SHORTCUTS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS, XdpDbusImplGlobalShortcuts))
#define XDP_DBUS_IMPL_IS_GLOBAL_SHORTCUTS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS))
#define XDP_DBUS_IMPL_GLOBAL_SHORTCUTS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS, XdpDbusImplGlobalShortcutsIface))

struct _XdpDbusImplGlobalShortcuts;
typedef struct _XdpDbusImplGlobalShortcuts XdpDbusImplGlobalShortcuts;
typedef struct _XdpDbusImplGlobalShortcutsIface XdpDbusImplGlobalShortcutsIface;

struct _XdpDbusImplGlobalShortcutsIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_bind_shortcuts) (
    XdpDbusImplGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    GVariant *arg_shortcuts,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  gboolean (*handle_configure_shortcuts) (
    XdpDbusImplGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  gboolean (*handle_create_session) (
    XdpDbusImplGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

  gboolean (*handle_list_shortcuts) (
    XdpDbusImplGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle);

  guint  (*get_version) (XdpDbusImplGlobalShortcuts *object);

  void (*activated) (
    XdpDbusImplGlobalShortcuts *object,
    const gchar *arg_session_handle,
    const gchar *arg_shortcut_id,
    guint64 arg_timestamp,
    GVariant *arg_options);

  void (*deactivated) (
    XdpDbusImplGlobalShortcuts *object,
    const gchar *arg_session_handle,
    const gchar *arg_shortcut_id,
    guint64 arg_timestamp,
    GVariant *arg_options);

  void (*shortcuts_changed) (
    XdpDbusImplGlobalShortcuts *object,
    const gchar *arg_session_handle,
    GVariant *arg_shortcuts);

};

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

GType xdp_dbus_impl_global_shortcuts_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_global_shortcuts_interface_info (void);
guint xdp_dbus_impl_global_shortcuts_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_global_shortcuts_complete_create_session (
    XdpDbusImplGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_global_shortcuts_complete_bind_shortcuts (
    XdpDbusImplGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_global_shortcuts_complete_list_shortcuts (
    XdpDbusImplGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_global_shortcuts_complete_configure_shortcuts (
    XdpDbusImplGlobalShortcuts *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void xdp_dbus_impl_global_shortcuts_emit_activated (
    XdpDbusImplGlobalShortcuts *object,
    const gchar *arg_session_handle,
    const gchar *arg_shortcut_id,
    guint64 arg_timestamp,
    GVariant *arg_options);

void xdp_dbus_impl_global_shortcuts_emit_deactivated (
    XdpDbusImplGlobalShortcuts *object,
    const gchar *arg_session_handle,
    const gchar *arg_shortcut_id,
    guint64 arg_timestamp,
    GVariant *arg_options);

void xdp_dbus_impl_global_shortcuts_emit_shortcuts_changed (
    XdpDbusImplGlobalShortcuts *object,
    const gchar *arg_session_handle,
    GVariant *arg_shortcuts);



/* D-Bus method calls: */
void xdp_dbus_impl_global_shortcuts_call_create_session (
    XdpDbusImplGlobalShortcuts *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_global_shortcuts_call_create_session_finish (
    XdpDbusImplGlobalShortcuts *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_global_shortcuts_call_create_session_sync (
    XdpDbusImplGlobalShortcuts *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_global_shortcuts_call_bind_shortcuts (
    XdpDbusImplGlobalShortcuts *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    GVariant *arg_shortcuts,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_global_shortcuts_call_bind_shortcuts_finish (
    XdpDbusImplGlobalShortcuts *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_global_shortcuts_call_bind_shortcuts_sync (
    XdpDbusImplGlobalShortcuts *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    GVariant *arg_shortcuts,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_global_shortcuts_call_list_shortcuts (
    XdpDbusImplGlobalShortcuts *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_global_shortcuts_call_list_shortcuts_finish (
    XdpDbusImplGlobalShortcuts *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_global_shortcuts_call_list_shortcuts_sync (
    XdpDbusImplGlobalShortcuts *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_global_shortcuts_call_configure_shortcuts (
    XdpDbusImplGlobalShortcuts *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_global_shortcuts_call_configure_shortcuts_finish (
    XdpDbusImplGlobalShortcuts *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_global_shortcuts_call_configure_shortcuts_sync (
    XdpDbusImplGlobalShortcuts *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_impl_global_shortcuts_get_version (XdpDbusImplGlobalShortcuts *object);
void xdp_dbus_impl_global_shortcuts_set_version (XdpDbusImplGlobalShortcuts *object, guint value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS_PROXY (xdp_dbus_impl_global_shortcuts_proxy_get_type ())
#define XDP_DBUS_IMPL_GLOBAL_SHORTCUTS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS_PROXY, XdpDbusImplGlobalShortcutsProxy))
#define XDP_DBUS_IMPL_GLOBAL_SHORTCUTS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS_PROXY, XdpDbusImplGlobalShortcutsProxyClass))
#define XDP_DBUS_IMPL_GLOBAL_SHORTCUTS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS_PROXY, XdpDbusImplGlobalShortcutsProxyClass))
#define XDP_DBUS_IMPL_IS_GLOBAL_SHORTCUTS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS_PROXY))
#define XDP_DBUS_IMPL_IS_GLOBAL_SHORTCUTS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS_PROXY))

typedef struct _XdpDbusImplGlobalShortcutsProxy XdpDbusImplGlobalShortcutsProxy;
typedef struct _XdpDbusImplGlobalShortcutsProxyClass XdpDbusImplGlobalShortcutsProxyClass;
typedef struct _XdpDbusImplGlobalShortcutsProxyPrivate XdpDbusImplGlobalShortcutsProxyPrivate;

struct _XdpDbusImplGlobalShortcutsProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplGlobalShortcutsProxyPrivate *priv;
};

struct _XdpDbusImplGlobalShortcutsProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_global_shortcuts_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_global_shortcuts_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplGlobalShortcuts *xdp_dbus_impl_global_shortcuts_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplGlobalShortcuts *xdp_dbus_impl_global_shortcuts_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_global_shortcuts_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplGlobalShortcuts *xdp_dbus_impl_global_shortcuts_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplGlobalShortcuts *xdp_dbus_impl_global_shortcuts_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS_SKELETON (xdp_dbus_impl_global_shortcuts_skeleton_get_type ())
#define XDP_DBUS_IMPL_GLOBAL_SHORTCUTS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS_SKELETON, XdpDbusImplGlobalShortcutsSkeleton))
#define XDP_DBUS_IMPL_GLOBAL_SHORTCUTS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS_SKELETON, XdpDbusImplGlobalShortcutsSkeletonClass))
#define XDP_DBUS_IMPL_GLOBAL_SHORTCUTS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS_SKELETON, XdpDbusImplGlobalShortcutsSkeletonClass))
#define XDP_DBUS_IMPL_IS_GLOBAL_SHORTCUTS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS_SKELETON))
#define XDP_DBUS_IMPL_IS_GLOBAL_SHORTCUTS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_GLOBAL_SHORTCUTS_SKELETON))

typedef struct _XdpDbusImplGlobalShortcutsSkeleton XdpDbusImplGlobalShortcutsSkeleton;
typedef struct _XdpDbusImplGlobalShortcutsSkeletonClass XdpDbusImplGlobalShortcutsSkeletonClass;
typedef struct _XdpDbusImplGlobalShortcutsSkeletonPrivate XdpDbusImplGlobalShortcutsSkeletonPrivate;

struct _XdpDbusImplGlobalShortcutsSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplGlobalShortcutsSkeletonPrivate *priv;
};

struct _XdpDbusImplGlobalShortcutsSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_global_shortcuts_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplGlobalShortcuts *xdp_dbus_impl_global_shortcuts_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Inhibit */

#define XDP_DBUS_IMPL_TYPE_INHIBIT (xdp_dbus_impl_inhibit_get_type ())
#define XDP_DBUS_IMPL_INHIBIT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_INHIBIT, XdpDbusImplInhibit))
#define XDP_DBUS_IMPL_IS_INHIBIT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_INHIBIT))
#define XDP_DBUS_IMPL_INHIBIT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_INHIBIT, XdpDbusImplInhibitIface))

struct _XdpDbusImplInhibit;
typedef struct _XdpDbusImplInhibit XdpDbusImplInhibit;
typedef struct _XdpDbusImplInhibitIface XdpDbusImplInhibitIface;

struct _XdpDbusImplInhibitIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_create_monitor) (
    XdpDbusImplInhibit *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_window);

  gboolean (*handle_inhibit) (
    XdpDbusImplInhibit *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_window,
    guint arg_flags,
    GVariant *arg_options);

  gboolean (*handle_query_end_response) (
    XdpDbusImplInhibit *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle);

  void (*state_changed) (
    XdpDbusImplInhibit *object,
    const gchar *arg_session_handle,
    GVariant *arg_state);

};

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

GType xdp_dbus_impl_inhibit_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_inhibit_interface_info (void);
guint xdp_dbus_impl_inhibit_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_dbus_impl_inhibit_complete_create_monitor (
    XdpDbusImplInhibit *object,
    GDBusMethodInvocation *invocation,
    guint response);

void xdp_dbus_impl_inhibit_complete_query_end_response (
    XdpDbusImplInhibit *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void xdp_dbus_impl_inhibit_emit_state_changed (
    XdpDbusImplInhibit *object,
    const gchar *arg_session_handle,
    GVariant *arg_state);



/* D-Bus method calls: */
void xdp_dbus_impl_inhibit_call_inhibit (
    XdpDbusImplInhibit *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_window,
    guint arg_flags,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_inhibit_call_inhibit_finish (
    XdpDbusImplInhibit *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_inhibit_call_inhibit_sync (
    XdpDbusImplInhibit *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_window,
    guint arg_flags,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_inhibit_call_create_monitor (
    XdpDbusImplInhibit *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_window,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_inhibit_call_create_monitor_finish (
    XdpDbusImplInhibit *proxy,
    guint* out_response,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_inhibit_call_create_monitor_sync (
    XdpDbusImplInhibit *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_window,
    guint* out_response,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_inhibit_call_query_end_response (
    XdpDbusImplInhibit *proxy,
    const gchar *arg_session_handle,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_inhibit_call_query_end_response_finish (
    XdpDbusImplInhibit *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_inhibit_call_query_end_response_sync (
    XdpDbusImplInhibit *proxy,
    const gchar *arg_session_handle,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_DBUS_IMPL_TYPE_INHIBIT_PROXY (xdp_dbus_impl_inhibit_proxy_get_type ())
#define XDP_DBUS_IMPL_INHIBIT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_INHIBIT_PROXY, XdpDbusImplInhibitProxy))
#define XDP_DBUS_IMPL_INHIBIT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_INHIBIT_PROXY, XdpDbusImplInhibitProxyClass))
#define XDP_DBUS_IMPL_INHIBIT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_INHIBIT_PROXY, XdpDbusImplInhibitProxyClass))
#define XDP_DBUS_IMPL_IS_INHIBIT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_INHIBIT_PROXY))
#define XDP_DBUS_IMPL_IS_INHIBIT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_INHIBIT_PROXY))

typedef struct _XdpDbusImplInhibitProxy XdpDbusImplInhibitProxy;
typedef struct _XdpDbusImplInhibitProxyClass XdpDbusImplInhibitProxyClass;
typedef struct _XdpDbusImplInhibitProxyPrivate XdpDbusImplInhibitProxyPrivate;

struct _XdpDbusImplInhibitProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplInhibitProxyPrivate *priv;
};

struct _XdpDbusImplInhibitProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_inhibit_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_inhibit_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplInhibit *xdp_dbus_impl_inhibit_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplInhibit *xdp_dbus_impl_inhibit_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_inhibit_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplInhibit *xdp_dbus_impl_inhibit_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplInhibit *xdp_dbus_impl_inhibit_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_INHIBIT_SKELETON (xdp_dbus_impl_inhibit_skeleton_get_type ())
#define XDP_DBUS_IMPL_INHIBIT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_INHIBIT_SKELETON, XdpDbusImplInhibitSkeleton))
#define XDP_DBUS_IMPL_INHIBIT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_INHIBIT_SKELETON, XdpDbusImplInhibitSkeletonClass))
#define XDP_DBUS_IMPL_INHIBIT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_INHIBIT_SKELETON, XdpDbusImplInhibitSkeletonClass))
#define XDP_DBUS_IMPL_IS_INHIBIT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_INHIBIT_SKELETON))
#define XDP_DBUS_IMPL_IS_INHIBIT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_INHIBIT_SKELETON))

typedef struct _XdpDbusImplInhibitSkeleton XdpDbusImplInhibitSkeleton;
typedef struct _XdpDbusImplInhibitSkeletonClass XdpDbusImplInhibitSkeletonClass;
typedef struct _XdpDbusImplInhibitSkeletonPrivate XdpDbusImplInhibitSkeletonPrivate;

struct _XdpDbusImplInhibitSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplInhibitSkeletonPrivate *priv;
};

struct _XdpDbusImplInhibitSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_inhibit_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplInhibit *xdp_dbus_impl_inhibit_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.InputCapture */

#define XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE (xdp_dbus_impl_input_capture_get_type ())
#define XDP_DBUS_IMPL_INPUT_CAPTURE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE, XdpDbusImplInputCapture))
#define XDP_DBUS_IMPL_IS_INPUT_CAPTURE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE))
#define XDP_DBUS_IMPL_INPUT_CAPTURE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE, XdpDbusImplInputCaptureIface))

struct _XdpDbusImplInputCapture;
typedef struct _XdpDbusImplInputCapture XdpDbusImplInputCapture;
typedef struct _XdpDbusImplInputCaptureIface XdpDbusImplInputCaptureIface;

struct _XdpDbusImplInputCaptureIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_connect_to_eis) (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

  gboolean (*handle_create_session) (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  gboolean (*handle_create_session2) (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

  gboolean (*handle_disable) (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

  gboolean (*handle_enable) (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

  gboolean (*handle_get_zones) (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

  gboolean (*handle_release) (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

  gboolean (*handle_set_pointer_barriers) (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GVariant *arg_barriers,
    guint arg_zone_set);

  gboolean (*handle_start) (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  guint  (*get_supported_capabilities) (XdpDbusImplInputCapture *object);

  guint  (*get_version) (XdpDbusImplInputCapture *object);

  void (*activated) (
    XdpDbusImplInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);

  void (*deactivated) (
    XdpDbusImplInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);

  void (*disabled) (
    XdpDbusImplInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);

  void (*zones_changed) (
    XdpDbusImplInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);

};

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

GType xdp_dbus_impl_input_capture_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_input_capture_interface_info (void);
guint xdp_dbus_impl_input_capture_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_input_capture_complete_create_session (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_input_capture_complete_create_session2 (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    GVariant *results);

void xdp_dbus_impl_input_capture_complete_start (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_input_capture_complete_get_zones (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_input_capture_complete_set_pointer_barriers (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_input_capture_complete_enable (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_input_capture_complete_disable (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_input_capture_complete_release (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_input_capture_complete_connect_to_eis (
    XdpDbusImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);



/* D-Bus signal emissions functions: */
void xdp_dbus_impl_input_capture_emit_disabled (
    XdpDbusImplInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);

void xdp_dbus_impl_input_capture_emit_activated (
    XdpDbusImplInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);

void xdp_dbus_impl_input_capture_emit_deactivated (
    XdpDbusImplInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);

void xdp_dbus_impl_input_capture_emit_zones_changed (
    XdpDbusImplInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);



/* D-Bus method calls: */
void xdp_dbus_impl_input_capture_call_create_session (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_input_capture_call_create_session_finish (
    XdpDbusImplInputCapture *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_input_capture_call_create_session_sync (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_input_capture_call_create_session2 (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_input_capture_call_create_session2_finish (
    XdpDbusImplInputCapture *proxy,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_input_capture_call_create_session2_sync (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_input_capture_call_start (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_input_capture_call_start_finish (
    XdpDbusImplInputCapture *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_input_capture_call_start_sync (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_input_capture_call_get_zones (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_input_capture_call_get_zones_finish (
    XdpDbusImplInputCapture *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_input_capture_call_get_zones_sync (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_input_capture_call_set_pointer_barriers (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GVariant *arg_barriers,
    guint arg_zone_set,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_input_capture_call_set_pointer_barriers_finish (
    XdpDbusImplInputCapture *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_input_capture_call_set_pointer_barriers_sync (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GVariant *arg_barriers,
    guint arg_zone_set,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_input_capture_call_enable (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_input_capture_call_enable_finish (
    XdpDbusImplInputCapture *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_input_capture_call_enable_sync (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_input_capture_call_disable (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_input_capture_call_disable_finish (
    XdpDbusImplInputCapture *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_input_capture_call_disable_sync (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_input_capture_call_release (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_input_capture_call_release_finish (
    XdpDbusImplInputCapture *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_input_capture_call_release_sync (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_input_capture_call_connect_to_eis (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_input_capture_call_connect_to_eis_finish (
    XdpDbusImplInputCapture *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_input_capture_call_connect_to_eis_sync (
    XdpDbusImplInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_impl_input_capture_get_supported_capabilities (XdpDbusImplInputCapture *object);
void xdp_dbus_impl_input_capture_set_supported_capabilities (XdpDbusImplInputCapture *object, guint value);

guint xdp_dbus_impl_input_capture_get_version (XdpDbusImplInputCapture *object);
void xdp_dbus_impl_input_capture_set_version (XdpDbusImplInputCapture *object, guint value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE_PROXY (xdp_dbus_impl_input_capture_proxy_get_type ())
#define XDP_DBUS_IMPL_INPUT_CAPTURE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE_PROXY, XdpDbusImplInputCaptureProxy))
#define XDP_DBUS_IMPL_INPUT_CAPTURE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE_PROXY, XdpDbusImplInputCaptureProxyClass))
#define XDP_DBUS_IMPL_INPUT_CAPTURE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE_PROXY, XdpDbusImplInputCaptureProxyClass))
#define XDP_DBUS_IMPL_IS_INPUT_CAPTURE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE_PROXY))
#define XDP_DBUS_IMPL_IS_INPUT_CAPTURE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE_PROXY))

typedef struct _XdpDbusImplInputCaptureProxy XdpDbusImplInputCaptureProxy;
typedef struct _XdpDbusImplInputCaptureProxyClass XdpDbusImplInputCaptureProxyClass;
typedef struct _XdpDbusImplInputCaptureProxyPrivate XdpDbusImplInputCaptureProxyPrivate;

struct _XdpDbusImplInputCaptureProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplInputCaptureProxyPrivate *priv;
};

struct _XdpDbusImplInputCaptureProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_input_capture_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_input_capture_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplInputCapture *xdp_dbus_impl_input_capture_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplInputCapture *xdp_dbus_impl_input_capture_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_input_capture_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplInputCapture *xdp_dbus_impl_input_capture_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplInputCapture *xdp_dbus_impl_input_capture_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE_SKELETON (xdp_dbus_impl_input_capture_skeleton_get_type ())
#define XDP_DBUS_IMPL_INPUT_CAPTURE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE_SKELETON, XdpDbusImplInputCaptureSkeleton))
#define XDP_DBUS_IMPL_INPUT_CAPTURE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE_SKELETON, XdpDbusImplInputCaptureSkeletonClass))
#define XDP_DBUS_IMPL_INPUT_CAPTURE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE_SKELETON, XdpDbusImplInputCaptureSkeletonClass))
#define XDP_DBUS_IMPL_IS_INPUT_CAPTURE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE_SKELETON))
#define XDP_DBUS_IMPL_IS_INPUT_CAPTURE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_INPUT_CAPTURE_SKELETON))

typedef struct _XdpDbusImplInputCaptureSkeleton XdpDbusImplInputCaptureSkeleton;
typedef struct _XdpDbusImplInputCaptureSkeletonClass XdpDbusImplInputCaptureSkeletonClass;
typedef struct _XdpDbusImplInputCaptureSkeletonPrivate XdpDbusImplInputCaptureSkeletonPrivate;

struct _XdpDbusImplInputCaptureSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplInputCaptureSkeletonPrivate *priv;
};

struct _XdpDbusImplInputCaptureSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_input_capture_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplInputCapture *xdp_dbus_impl_input_capture_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Lockdown */

#define XDP_DBUS_IMPL_TYPE_LOCKDOWN (xdp_dbus_impl_lockdown_get_type ())
#define XDP_DBUS_IMPL_LOCKDOWN(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_LOCKDOWN, XdpDbusImplLockdown))
#define XDP_DBUS_IMPL_IS_LOCKDOWN(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_LOCKDOWN))
#define XDP_DBUS_IMPL_LOCKDOWN_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_LOCKDOWN, XdpDbusImplLockdownIface))

struct _XdpDbusImplLockdown;
typedef struct _XdpDbusImplLockdown XdpDbusImplLockdown;
typedef struct _XdpDbusImplLockdownIface XdpDbusImplLockdownIface;

struct _XdpDbusImplLockdownIface
{
  GTypeInterface parent_iface;

  gboolean  (*get_disable_application_handlers) (XdpDbusImplLockdown *object);

  gboolean  (*get_disable_camera) (XdpDbusImplLockdown *object);

  gboolean  (*get_disable_location) (XdpDbusImplLockdown *object);

  gboolean  (*get_disable_microphone) (XdpDbusImplLockdown *object);

  gboolean  (*get_disable_printing) (XdpDbusImplLockdown *object);

  gboolean  (*get_disable_save_to_disk) (XdpDbusImplLockdown *object);

  gboolean  (*get_disable_sound_output) (XdpDbusImplLockdown *object);

};

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

GType xdp_dbus_impl_lockdown_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_lockdown_interface_info (void);
guint xdp_dbus_impl_lockdown_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus property accessors: */
gboolean xdp_dbus_impl_lockdown_get_disable_printing (XdpDbusImplLockdown *object);
void xdp_dbus_impl_lockdown_set_disable_printing (XdpDbusImplLockdown *object, gboolean value);

gboolean xdp_dbus_impl_lockdown_get_disable_save_to_disk (XdpDbusImplLockdown *object);
void xdp_dbus_impl_lockdown_set_disable_save_to_disk (XdpDbusImplLockdown *object, gboolean value);

gboolean xdp_dbus_impl_lockdown_get_disable_application_handlers (XdpDbusImplLockdown *object);
void xdp_dbus_impl_lockdown_set_disable_application_handlers (XdpDbusImplLockdown *object, gboolean value);

gboolean xdp_dbus_impl_lockdown_get_disable_location (XdpDbusImplLockdown *object);
void xdp_dbus_impl_lockdown_set_disable_location (XdpDbusImplLockdown *object, gboolean value);

gboolean xdp_dbus_impl_lockdown_get_disable_camera (XdpDbusImplLockdown *object);
void xdp_dbus_impl_lockdown_set_disable_camera (XdpDbusImplLockdown *object, gboolean value);

gboolean xdp_dbus_impl_lockdown_get_disable_microphone (XdpDbusImplLockdown *object);
void xdp_dbus_impl_lockdown_set_disable_microphone (XdpDbusImplLockdown *object, gboolean value);

gboolean xdp_dbus_impl_lockdown_get_disable_sound_output (XdpDbusImplLockdown *object);
void xdp_dbus_impl_lockdown_set_disable_sound_output (XdpDbusImplLockdown *object, gboolean value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_LOCKDOWN_PROXY (xdp_dbus_impl_lockdown_proxy_get_type ())
#define XDP_DBUS_IMPL_LOCKDOWN_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_LOCKDOWN_PROXY, XdpDbusImplLockdownProxy))
#define XDP_DBUS_IMPL_LOCKDOWN_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_LOCKDOWN_PROXY, XdpDbusImplLockdownProxyClass))
#define XDP_DBUS_IMPL_LOCKDOWN_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_LOCKDOWN_PROXY, XdpDbusImplLockdownProxyClass))
#define XDP_DBUS_IMPL_IS_LOCKDOWN_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_LOCKDOWN_PROXY))
#define XDP_DBUS_IMPL_IS_LOCKDOWN_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_LOCKDOWN_PROXY))

typedef struct _XdpDbusImplLockdownProxy XdpDbusImplLockdownProxy;
typedef struct _XdpDbusImplLockdownProxyClass XdpDbusImplLockdownProxyClass;
typedef struct _XdpDbusImplLockdownProxyPrivate XdpDbusImplLockdownProxyPrivate;

struct _XdpDbusImplLockdownProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplLockdownProxyPrivate *priv;
};

struct _XdpDbusImplLockdownProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_lockdown_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_lockdown_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplLockdown *xdp_dbus_impl_lockdown_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplLockdown *xdp_dbus_impl_lockdown_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_lockdown_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplLockdown *xdp_dbus_impl_lockdown_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplLockdown *xdp_dbus_impl_lockdown_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_LOCKDOWN_SKELETON (xdp_dbus_impl_lockdown_skeleton_get_type ())
#define XDP_DBUS_IMPL_LOCKDOWN_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_LOCKDOWN_SKELETON, XdpDbusImplLockdownSkeleton))
#define XDP_DBUS_IMPL_LOCKDOWN_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_LOCKDOWN_SKELETON, XdpDbusImplLockdownSkeletonClass))
#define XDP_DBUS_IMPL_LOCKDOWN_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_LOCKDOWN_SKELETON, XdpDbusImplLockdownSkeletonClass))
#define XDP_DBUS_IMPL_IS_LOCKDOWN_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_LOCKDOWN_SKELETON))
#define XDP_DBUS_IMPL_IS_LOCKDOWN_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_LOCKDOWN_SKELETON))

typedef struct _XdpDbusImplLockdownSkeleton XdpDbusImplLockdownSkeleton;
typedef struct _XdpDbusImplLockdownSkeletonClass XdpDbusImplLockdownSkeletonClass;
typedef struct _XdpDbusImplLockdownSkeletonPrivate XdpDbusImplLockdownSkeletonPrivate;

struct _XdpDbusImplLockdownSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplLockdownSkeletonPrivate *priv;
};

struct _XdpDbusImplLockdownSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_lockdown_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplLockdown *xdp_dbus_impl_lockdown_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Notification */

#define XDP_DBUS_IMPL_TYPE_NOTIFICATION (xdp_dbus_impl_notification_get_type ())
#define XDP_DBUS_IMPL_NOTIFICATION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_NOTIFICATION, XdpDbusImplNotification))
#define XDP_DBUS_IMPL_IS_NOTIFICATION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_NOTIFICATION))
#define XDP_DBUS_IMPL_NOTIFICATION_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_NOTIFICATION, XdpDbusImplNotificationIface))

struct _XdpDbusImplNotification;
typedef struct _XdpDbusImplNotification XdpDbusImplNotification;
typedef struct _XdpDbusImplNotificationIface XdpDbusImplNotificationIface;

struct _XdpDbusImplNotificationIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_add_notification) (
    XdpDbusImplNotification *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_app_id,
    const gchar *arg_id,
    GVariant *arg_notification);

  gboolean (*handle_remove_notification) (
    XdpDbusImplNotification *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_app_id,
    const gchar *arg_id);

  GVariant * (*get_supported_options) (XdpDbusImplNotification *object);

  guint  (*get_version) (XdpDbusImplNotification *object);

  void (*action_invoked) (
    XdpDbusImplNotification *object,
    const gchar *arg_app_id,
    const gchar *arg_id,
    const gchar *arg_action,
    GVariant *arg_parameter);

};

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

GType xdp_dbus_impl_notification_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_notification_interface_info (void);
guint xdp_dbus_impl_notification_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_notification_complete_add_notification (
    XdpDbusImplNotification *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list);

void xdp_dbus_impl_notification_complete_remove_notification (
    XdpDbusImplNotification *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void xdp_dbus_impl_notification_emit_action_invoked (
    XdpDbusImplNotification *object,
    const gchar *arg_app_id,
    const gchar *arg_id,
    const gchar *arg_action,
    GVariant *arg_parameter);



/* D-Bus method calls: */
void xdp_dbus_impl_notification_call_add_notification (
    XdpDbusImplNotification *proxy,
    const gchar *arg_app_id,
    const gchar *arg_id,
    GVariant *arg_notification,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_notification_call_add_notification_finish (
    XdpDbusImplNotification *proxy,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_notification_call_add_notification_sync (
    XdpDbusImplNotification *proxy,
    const gchar *arg_app_id,
    const gchar *arg_id,
    GVariant *arg_notification,
    GUnixFDList  *fd_list,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_notification_call_remove_notification (
    XdpDbusImplNotification *proxy,
    const gchar *arg_app_id,
    const gchar *arg_id,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_notification_call_remove_notification_finish (
    XdpDbusImplNotification *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_notification_call_remove_notification_sync (
    XdpDbusImplNotification *proxy,
    const gchar *arg_app_id,
    const gchar *arg_id,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
GVariant *xdp_dbus_impl_notification_get_supported_options (XdpDbusImplNotification *object);
GVariant *xdp_dbus_impl_notification_dup_supported_options (XdpDbusImplNotification *object);
void xdp_dbus_impl_notification_set_supported_options (XdpDbusImplNotification *object, GVariant *value);

guint xdp_dbus_impl_notification_get_version (XdpDbusImplNotification *object);
void xdp_dbus_impl_notification_set_version (XdpDbusImplNotification *object, guint value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_NOTIFICATION_PROXY (xdp_dbus_impl_notification_proxy_get_type ())
#define XDP_DBUS_IMPL_NOTIFICATION_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_NOTIFICATION_PROXY, XdpDbusImplNotificationProxy))
#define XDP_DBUS_IMPL_NOTIFICATION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_NOTIFICATION_PROXY, XdpDbusImplNotificationProxyClass))
#define XDP_DBUS_IMPL_NOTIFICATION_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_NOTIFICATION_PROXY, XdpDbusImplNotificationProxyClass))
#define XDP_DBUS_IMPL_IS_NOTIFICATION_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_NOTIFICATION_PROXY))
#define XDP_DBUS_IMPL_IS_NOTIFICATION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_NOTIFICATION_PROXY))

typedef struct _XdpDbusImplNotificationProxy XdpDbusImplNotificationProxy;
typedef struct _XdpDbusImplNotificationProxyClass XdpDbusImplNotificationProxyClass;
typedef struct _XdpDbusImplNotificationProxyPrivate XdpDbusImplNotificationProxyPrivate;

struct _XdpDbusImplNotificationProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplNotificationProxyPrivate *priv;
};

struct _XdpDbusImplNotificationProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_notification_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_notification_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplNotification *xdp_dbus_impl_notification_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplNotification *xdp_dbus_impl_notification_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_notification_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplNotification *xdp_dbus_impl_notification_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplNotification *xdp_dbus_impl_notification_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_NOTIFICATION_SKELETON (xdp_dbus_impl_notification_skeleton_get_type ())
#define XDP_DBUS_IMPL_NOTIFICATION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_NOTIFICATION_SKELETON, XdpDbusImplNotificationSkeleton))
#define XDP_DBUS_IMPL_NOTIFICATION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_NOTIFICATION_SKELETON, XdpDbusImplNotificationSkeletonClass))
#define XDP_DBUS_IMPL_NOTIFICATION_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_NOTIFICATION_SKELETON, XdpDbusImplNotificationSkeletonClass))
#define XDP_DBUS_IMPL_IS_NOTIFICATION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_NOTIFICATION_SKELETON))
#define XDP_DBUS_IMPL_IS_NOTIFICATION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_NOTIFICATION_SKELETON))

typedef struct _XdpDbusImplNotificationSkeleton XdpDbusImplNotificationSkeleton;
typedef struct _XdpDbusImplNotificationSkeletonClass XdpDbusImplNotificationSkeletonClass;
typedef struct _XdpDbusImplNotificationSkeletonPrivate XdpDbusImplNotificationSkeletonPrivate;

struct _XdpDbusImplNotificationSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplNotificationSkeletonPrivate *priv;
};

struct _XdpDbusImplNotificationSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_notification_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplNotification *xdp_dbus_impl_notification_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.PermissionStore */

#define XDP_DBUS_IMPL_TYPE_PERMISSION_STORE (xdp_dbus_impl_permission_store_get_type ())
#define XDP_DBUS_IMPL_PERMISSION_STORE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_PERMISSION_STORE, XdpDbusImplPermissionStore))
#define XDP_DBUS_IMPL_IS_PERMISSION_STORE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_PERMISSION_STORE))
#define XDP_DBUS_IMPL_PERMISSION_STORE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_PERMISSION_STORE, XdpDbusImplPermissionStoreIface))

struct _XdpDbusImplPermissionStore;
typedef struct _XdpDbusImplPermissionStore XdpDbusImplPermissionStore;
typedef struct _XdpDbusImplPermissionStoreIface XdpDbusImplPermissionStoreIface;

struct _XdpDbusImplPermissionStoreIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_delete) (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_table,
    const gchar *arg_id);

  gboolean (*handle_delete_permission) (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_table,
    const gchar *arg_id,
    const gchar *arg_app);

  gboolean (*handle_get_permission) (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_table,
    const gchar *arg_id,
    const gchar *arg_app);

  gboolean (*handle_list) (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_table);

  gboolean (*handle_lookup) (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_table,
    const gchar *arg_id);

  gboolean (*handle_set) (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_table,
    gboolean arg_create,
    const gchar *arg_id,
    GVariant *arg_app_permissions,
    GVariant *arg_data);

  gboolean (*handle_set_permission) (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_table,
    gboolean arg_create,
    const gchar *arg_id,
    const gchar *arg_app,
    const gchar *const *arg_permissions);

  gboolean (*handle_set_value) (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_table,
    gboolean arg_create,
    const gchar *arg_id,
    GVariant *arg_data);

  guint  (*get_version) (XdpDbusImplPermissionStore *object);

  void (*changed) (
    XdpDbusImplPermissionStore *object,
    const gchar *arg_table,
    const gchar *arg_id,
    gboolean arg_deleted,
    GVariant *arg_data,
    GVariant *arg_permissions);

};

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

GType xdp_dbus_impl_permission_store_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_permission_store_interface_info (void);
guint xdp_dbus_impl_permission_store_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_permission_store_complete_lookup (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation,
    GVariant *permissions,
    GVariant *data);

void xdp_dbus_impl_permission_store_complete_set (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_permission_store_complete_delete (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_permission_store_complete_set_value (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_permission_store_complete_set_permission (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_permission_store_complete_delete_permission (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_permission_store_complete_get_permission (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *permissions);

void xdp_dbus_impl_permission_store_complete_list (
    XdpDbusImplPermissionStore *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *ids);



/* D-Bus signal emissions functions: */
void xdp_dbus_impl_permission_store_emit_changed (
    XdpDbusImplPermissionStore *object,
    const gchar *arg_table,
    const gchar *arg_id,
    gboolean arg_deleted,
    GVariant *arg_data,
    GVariant *arg_permissions);



/* D-Bus method calls: */
void xdp_dbus_impl_permission_store_call_lookup (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    const gchar *arg_id,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_permission_store_call_lookup_finish (
    XdpDbusImplPermissionStore *proxy,
    GVariant ** out_permissions,
    GVariant ** out_data,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_permission_store_call_lookup_sync (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    const gchar *arg_id,
    GVariant ** out_permissions,
    GVariant ** out_data,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_permission_store_call_set (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    gboolean arg_create,
    const gchar *arg_id,
    GVariant *arg_app_permissions,
    GVariant *arg_data,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_permission_store_call_set_finish (
    XdpDbusImplPermissionStore *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_permission_store_call_set_sync (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    gboolean arg_create,
    const gchar *arg_id,
    GVariant *arg_app_permissions,
    GVariant *arg_data,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_permission_store_call_delete (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    const gchar *arg_id,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_permission_store_call_delete_finish (
    XdpDbusImplPermissionStore *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_permission_store_call_delete_sync (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    const gchar *arg_id,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_permission_store_call_set_value (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    gboolean arg_create,
    const gchar *arg_id,
    GVariant *arg_data,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_permission_store_call_set_value_finish (
    XdpDbusImplPermissionStore *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_permission_store_call_set_value_sync (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    gboolean arg_create,
    const gchar *arg_id,
    GVariant *arg_data,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_permission_store_call_set_permission (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    gboolean arg_create,
    const gchar *arg_id,
    const gchar *arg_app,
    const gchar *const *arg_permissions,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_permission_store_call_set_permission_finish (
    XdpDbusImplPermissionStore *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_permission_store_call_set_permission_sync (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    gboolean arg_create,
    const gchar *arg_id,
    const gchar *arg_app,
    const gchar *const *arg_permissions,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_permission_store_call_delete_permission (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    const gchar *arg_id,
    const gchar *arg_app,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_permission_store_call_delete_permission_finish (
    XdpDbusImplPermissionStore *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_permission_store_call_delete_permission_sync (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    const gchar *arg_id,
    const gchar *arg_app,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_permission_store_call_get_permission (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    const gchar *arg_id,
    const gchar *arg_app,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_permission_store_call_get_permission_finish (
    XdpDbusImplPermissionStore *proxy,
    gchar *** out_permissions,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_permission_store_call_get_permission_sync (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    const gchar *arg_id,
    const gchar *arg_app,
    gchar *** out_permissions,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_permission_store_call_list (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_permission_store_call_list_finish (
    XdpDbusImplPermissionStore *proxy,
    gchar *** out_ids,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_permission_store_call_list_sync (
    XdpDbusImplPermissionStore *proxy,
    const gchar *arg_table,
    gchar *** out_ids,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_impl_permission_store_get_version (XdpDbusImplPermissionStore *object);
void xdp_dbus_impl_permission_store_set_version (XdpDbusImplPermissionStore *object, guint value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_PERMISSION_STORE_PROXY (xdp_dbus_impl_permission_store_proxy_get_type ())
#define XDP_DBUS_IMPL_PERMISSION_STORE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_PERMISSION_STORE_PROXY, XdpDbusImplPermissionStoreProxy))
#define XDP_DBUS_IMPL_PERMISSION_STORE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_PERMISSION_STORE_PROXY, XdpDbusImplPermissionStoreProxyClass))
#define XDP_DBUS_IMPL_PERMISSION_STORE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_PERMISSION_STORE_PROXY, XdpDbusImplPermissionStoreProxyClass))
#define XDP_DBUS_IMPL_IS_PERMISSION_STORE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_PERMISSION_STORE_PROXY))
#define XDP_DBUS_IMPL_IS_PERMISSION_STORE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_PERMISSION_STORE_PROXY))

typedef struct _XdpDbusImplPermissionStoreProxy XdpDbusImplPermissionStoreProxy;
typedef struct _XdpDbusImplPermissionStoreProxyClass XdpDbusImplPermissionStoreProxyClass;
typedef struct _XdpDbusImplPermissionStoreProxyPrivate XdpDbusImplPermissionStoreProxyPrivate;

struct _XdpDbusImplPermissionStoreProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplPermissionStoreProxyPrivate *priv;
};

struct _XdpDbusImplPermissionStoreProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_permission_store_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_permission_store_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplPermissionStore *xdp_dbus_impl_permission_store_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplPermissionStore *xdp_dbus_impl_permission_store_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_permission_store_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplPermissionStore *xdp_dbus_impl_permission_store_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplPermissionStore *xdp_dbus_impl_permission_store_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_PERMISSION_STORE_SKELETON (xdp_dbus_impl_permission_store_skeleton_get_type ())
#define XDP_DBUS_IMPL_PERMISSION_STORE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_PERMISSION_STORE_SKELETON, XdpDbusImplPermissionStoreSkeleton))
#define XDP_DBUS_IMPL_PERMISSION_STORE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_PERMISSION_STORE_SKELETON, XdpDbusImplPermissionStoreSkeletonClass))
#define XDP_DBUS_IMPL_PERMISSION_STORE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_PERMISSION_STORE_SKELETON, XdpDbusImplPermissionStoreSkeletonClass))
#define XDP_DBUS_IMPL_IS_PERMISSION_STORE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_PERMISSION_STORE_SKELETON))
#define XDP_DBUS_IMPL_IS_PERMISSION_STORE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_PERMISSION_STORE_SKELETON))

typedef struct _XdpDbusImplPermissionStoreSkeleton XdpDbusImplPermissionStoreSkeleton;
typedef struct _XdpDbusImplPermissionStoreSkeletonClass XdpDbusImplPermissionStoreSkeletonClass;
typedef struct _XdpDbusImplPermissionStoreSkeletonPrivate XdpDbusImplPermissionStoreSkeletonPrivate;

struct _XdpDbusImplPermissionStoreSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplPermissionStoreSkeletonPrivate *priv;
};

struct _XdpDbusImplPermissionStoreSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_permission_store_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplPermissionStore *xdp_dbus_impl_permission_store_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Print */

#define XDP_DBUS_IMPL_TYPE_PRINT (xdp_dbus_impl_print_get_type ())
#define XDP_DBUS_IMPL_PRINT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_PRINT, XdpDbusImplPrint))
#define XDP_DBUS_IMPL_IS_PRINT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_PRINT))
#define XDP_DBUS_IMPL_PRINT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_PRINT, XdpDbusImplPrintIface))

struct _XdpDbusImplPrint;
typedef struct _XdpDbusImplPrint XdpDbusImplPrint;
typedef struct _XdpDbusImplPrintIface XdpDbusImplPrintIface;

struct _XdpDbusImplPrintIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_prepare_print) (
    XdpDbusImplPrint *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_settings,
    GVariant *arg_page_setup,
    GVariant *arg_options);

  gboolean (*handle_print) (
    XdpDbusImplPrint *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_fd,
    GVariant *arg_options);

};

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

GType xdp_dbus_impl_print_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_print_interface_info (void);
guint xdp_dbus_impl_print_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_print_complete_prepare_print (
    XdpDbusImplPrint *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_print_complete_print (
    XdpDbusImplPrint *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    guint response,
    GVariant *results);



/* D-Bus method calls: */
void xdp_dbus_impl_print_call_prepare_print (
    XdpDbusImplPrint *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_settings,
    GVariant *arg_page_setup,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_print_call_prepare_print_finish (
    XdpDbusImplPrint *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_print_call_prepare_print_sync (
    XdpDbusImplPrint *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_settings,
    GVariant *arg_page_setup,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_print_call_print (
    XdpDbusImplPrint *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_print_call_print_finish (
    XdpDbusImplPrint *proxy,
    guint* out_response,
    GVariant ** out_results,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_print_call_print_sync (
    XdpDbusImplPrint *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    guint* out_response,
    GVariant ** out_results,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_DBUS_IMPL_TYPE_PRINT_PROXY (xdp_dbus_impl_print_proxy_get_type ())
#define XDP_DBUS_IMPL_PRINT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_PRINT_PROXY, XdpDbusImplPrintProxy))
#define XDP_DBUS_IMPL_PRINT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_PRINT_PROXY, XdpDbusImplPrintProxyClass))
#define XDP_DBUS_IMPL_PRINT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_PRINT_PROXY, XdpDbusImplPrintProxyClass))
#define XDP_DBUS_IMPL_IS_PRINT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_PRINT_PROXY))
#define XDP_DBUS_IMPL_IS_PRINT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_PRINT_PROXY))

typedef struct _XdpDbusImplPrintProxy XdpDbusImplPrintProxy;
typedef struct _XdpDbusImplPrintProxyClass XdpDbusImplPrintProxyClass;
typedef struct _XdpDbusImplPrintProxyPrivate XdpDbusImplPrintProxyPrivate;

struct _XdpDbusImplPrintProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplPrintProxyPrivate *priv;
};

struct _XdpDbusImplPrintProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_print_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_print_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplPrint *xdp_dbus_impl_print_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplPrint *xdp_dbus_impl_print_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_print_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplPrint *xdp_dbus_impl_print_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplPrint *xdp_dbus_impl_print_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_PRINT_SKELETON (xdp_dbus_impl_print_skeleton_get_type ())
#define XDP_DBUS_IMPL_PRINT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_PRINT_SKELETON, XdpDbusImplPrintSkeleton))
#define XDP_DBUS_IMPL_PRINT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_PRINT_SKELETON, XdpDbusImplPrintSkeletonClass))
#define XDP_DBUS_IMPL_PRINT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_PRINT_SKELETON, XdpDbusImplPrintSkeletonClass))
#define XDP_DBUS_IMPL_IS_PRINT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_PRINT_SKELETON))
#define XDP_DBUS_IMPL_IS_PRINT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_PRINT_SKELETON))

typedef struct _XdpDbusImplPrintSkeleton XdpDbusImplPrintSkeleton;
typedef struct _XdpDbusImplPrintSkeletonClass XdpDbusImplPrintSkeletonClass;
typedef struct _XdpDbusImplPrintSkeletonPrivate XdpDbusImplPrintSkeletonPrivate;

struct _XdpDbusImplPrintSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplPrintSkeletonPrivate *priv;
};

struct _XdpDbusImplPrintSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_print_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplPrint *xdp_dbus_impl_print_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.RemoteDesktop */

#define XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP (xdp_dbus_impl_remote_desktop_get_type ())
#define XDP_DBUS_IMPL_REMOTE_DESKTOP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP, XdpDbusImplRemoteDesktop))
#define XDP_DBUS_IMPL_IS_REMOTE_DESKTOP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP))
#define XDP_DBUS_IMPL_REMOTE_DESKTOP_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP, XdpDbusImplRemoteDesktopIface))

struct _XdpDbusImplRemoteDesktop;
typedef struct _XdpDbusImplRemoteDesktop XdpDbusImplRemoteDesktop;
typedef struct _XdpDbusImplRemoteDesktopIface XdpDbusImplRemoteDesktopIface;

struct _XdpDbusImplRemoteDesktopIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_connect_to_eis) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

  gboolean (*handle_create_session) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

  gboolean (*handle_notify_keyboard_keycode) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gint arg_keycode,
    guint arg_state);

  gboolean (*handle_notify_keyboard_keysym) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gint arg_keysym,
    guint arg_state);

  gboolean (*handle_notify_pointer_axis) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gdouble arg_dx,
    gdouble arg_dy);

  gboolean (*handle_notify_pointer_axis_discrete) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_axis,
    gint arg_steps);

  gboolean (*handle_notify_pointer_button) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gint arg_button,
    guint arg_state);

  gboolean (*handle_notify_pointer_motion) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gdouble arg_dx,
    gdouble arg_dy);

  gboolean (*handle_notify_pointer_motion_absolute) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_stream,
    gdouble arg_x,
    gdouble arg_y);

  gboolean (*handle_notify_touch_down) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_stream,
    guint arg_slot,
    gdouble arg_x,
    gdouble arg_y);

  gboolean (*handle_notify_touch_motion) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_stream,
    guint arg_slot,
    gdouble arg_x,
    gdouble arg_y);

  gboolean (*handle_notify_touch_up) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_slot);

  gboolean (*handle_select_devices) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

  gboolean (*handle_start) (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  guint  (*get_available_device_types) (XdpDbusImplRemoteDesktop *object);

  guint  (*get_version) (XdpDbusImplRemoteDesktop *object);

};

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

GType xdp_dbus_impl_remote_desktop_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_remote_desktop_interface_info (void);
guint xdp_dbus_impl_remote_desktop_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_remote_desktop_complete_create_session (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_remote_desktop_complete_select_devices (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_remote_desktop_complete_start (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_remote_desktop_complete_notify_pointer_motion (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_remote_desktop_complete_notify_pointer_motion_absolute (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_remote_desktop_complete_notify_pointer_button (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_remote_desktop_complete_notify_pointer_axis (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_remote_desktop_complete_notify_pointer_axis_discrete (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_remote_desktop_complete_notify_keyboard_keycode (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_remote_desktop_complete_notify_keyboard_keysym (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_remote_desktop_complete_notify_touch_down (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_remote_desktop_complete_notify_touch_motion (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_remote_desktop_complete_notify_touch_up (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_impl_remote_desktop_complete_connect_to_eis (
    XdpDbusImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);



/* D-Bus method calls: */
void xdp_dbus_impl_remote_desktop_call_create_session (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_create_session_finish (
    XdpDbusImplRemoteDesktop *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_create_session_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_remote_desktop_call_select_devices (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_select_devices_finish (
    XdpDbusImplRemoteDesktop *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_select_devices_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_remote_desktop_call_start (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_start_finish (
    XdpDbusImplRemoteDesktop *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_start_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_remote_desktop_call_notify_pointer_motion (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gdouble arg_dx,
    gdouble arg_dy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_notify_pointer_motion_finish (
    XdpDbusImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_notify_pointer_motion_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gdouble arg_dx,
    gdouble arg_dy,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_remote_desktop_call_notify_pointer_motion_absolute (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_stream,
    gdouble arg_x,
    gdouble arg_y,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_notify_pointer_motion_absolute_finish (
    XdpDbusImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_notify_pointer_motion_absolute_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_stream,
    gdouble arg_x,
    gdouble arg_y,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_remote_desktop_call_notify_pointer_button (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gint arg_button,
    guint arg_state,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_notify_pointer_button_finish (
    XdpDbusImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_notify_pointer_button_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gint arg_button,
    guint arg_state,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_remote_desktop_call_notify_pointer_axis (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gdouble arg_dx,
    gdouble arg_dy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_notify_pointer_axis_finish (
    XdpDbusImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_notify_pointer_axis_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gdouble arg_dx,
    gdouble arg_dy,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_remote_desktop_call_notify_pointer_axis_discrete (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_axis,
    gint arg_steps,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_notify_pointer_axis_discrete_finish (
    XdpDbusImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_notify_pointer_axis_discrete_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_axis,
    gint arg_steps,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_remote_desktop_call_notify_keyboard_keycode (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gint arg_keycode,
    guint arg_state,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_notify_keyboard_keycode_finish (
    XdpDbusImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_notify_keyboard_keycode_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gint arg_keycode,
    guint arg_state,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_remote_desktop_call_notify_keyboard_keysym (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gint arg_keysym,
    guint arg_state,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_notify_keyboard_keysym_finish (
    XdpDbusImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_notify_keyboard_keysym_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gint arg_keysym,
    guint arg_state,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_remote_desktop_call_notify_touch_down (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_stream,
    guint arg_slot,
    gdouble arg_x,
    gdouble arg_y,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_notify_touch_down_finish (
    XdpDbusImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_notify_touch_down_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_stream,
    guint arg_slot,
    gdouble arg_x,
    gdouble arg_y,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_remote_desktop_call_notify_touch_motion (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_stream,
    guint arg_slot,
    gdouble arg_x,
    gdouble arg_y,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_notify_touch_motion_finish (
    XdpDbusImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_notify_touch_motion_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_stream,
    guint arg_slot,
    gdouble arg_x,
    gdouble arg_y,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_remote_desktop_call_notify_touch_up (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_slot,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_notify_touch_up_finish (
    XdpDbusImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_notify_touch_up_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_slot,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_remote_desktop_call_connect_to_eis (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_remote_desktop_call_connect_to_eis_finish (
    XdpDbusImplRemoteDesktop *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_remote_desktop_call_connect_to_eis_sync (
    XdpDbusImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_impl_remote_desktop_get_available_device_types (XdpDbusImplRemoteDesktop *object);
void xdp_dbus_impl_remote_desktop_set_available_device_types (XdpDbusImplRemoteDesktop *object, guint value);

guint xdp_dbus_impl_remote_desktop_get_version (XdpDbusImplRemoteDesktop *object);
void xdp_dbus_impl_remote_desktop_set_version (XdpDbusImplRemoteDesktop *object, guint value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP_PROXY (xdp_dbus_impl_remote_desktop_proxy_get_type ())
#define XDP_DBUS_IMPL_REMOTE_DESKTOP_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP_PROXY, XdpDbusImplRemoteDesktopProxy))
#define XDP_DBUS_IMPL_REMOTE_DESKTOP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP_PROXY, XdpDbusImplRemoteDesktopProxyClass))
#define XDP_DBUS_IMPL_REMOTE_DESKTOP_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP_PROXY, XdpDbusImplRemoteDesktopProxyClass))
#define XDP_DBUS_IMPL_IS_REMOTE_DESKTOP_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP_PROXY))
#define XDP_DBUS_IMPL_IS_REMOTE_DESKTOP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP_PROXY))

typedef struct _XdpDbusImplRemoteDesktopProxy XdpDbusImplRemoteDesktopProxy;
typedef struct _XdpDbusImplRemoteDesktopProxyClass XdpDbusImplRemoteDesktopProxyClass;
typedef struct _XdpDbusImplRemoteDesktopProxyPrivate XdpDbusImplRemoteDesktopProxyPrivate;

struct _XdpDbusImplRemoteDesktopProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplRemoteDesktopProxyPrivate *priv;
};

struct _XdpDbusImplRemoteDesktopProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_remote_desktop_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_remote_desktop_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplRemoteDesktop *xdp_dbus_impl_remote_desktop_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplRemoteDesktop *xdp_dbus_impl_remote_desktop_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_remote_desktop_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplRemoteDesktop *xdp_dbus_impl_remote_desktop_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplRemoteDesktop *xdp_dbus_impl_remote_desktop_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP_SKELETON (xdp_dbus_impl_remote_desktop_skeleton_get_type ())
#define XDP_DBUS_IMPL_REMOTE_DESKTOP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP_SKELETON, XdpDbusImplRemoteDesktopSkeleton))
#define XDP_DBUS_IMPL_REMOTE_DESKTOP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP_SKELETON, XdpDbusImplRemoteDesktopSkeletonClass))
#define XDP_DBUS_IMPL_REMOTE_DESKTOP_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP_SKELETON, XdpDbusImplRemoteDesktopSkeletonClass))
#define XDP_DBUS_IMPL_IS_REMOTE_DESKTOP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP_SKELETON))
#define XDP_DBUS_IMPL_IS_REMOTE_DESKTOP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_REMOTE_DESKTOP_SKELETON))

typedef struct _XdpDbusImplRemoteDesktopSkeleton XdpDbusImplRemoteDesktopSkeleton;
typedef struct _XdpDbusImplRemoteDesktopSkeletonClass XdpDbusImplRemoteDesktopSkeletonClass;
typedef struct _XdpDbusImplRemoteDesktopSkeletonPrivate XdpDbusImplRemoteDesktopSkeletonPrivate;

struct _XdpDbusImplRemoteDesktopSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplRemoteDesktopSkeletonPrivate *priv;
};

struct _XdpDbusImplRemoteDesktopSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_remote_desktop_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplRemoteDesktop *xdp_dbus_impl_remote_desktop_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Request */

#define XDP_DBUS_IMPL_TYPE_REQUEST (xdp_dbus_impl_request_get_type ())
#define XDP_DBUS_IMPL_REQUEST(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_REQUEST, XdpDbusImplRequest))
#define XDP_DBUS_IMPL_IS_REQUEST(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_REQUEST))
#define XDP_DBUS_IMPL_REQUEST_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_REQUEST, XdpDbusImplRequestIface))

struct _XdpDbusImplRequest;
typedef struct _XdpDbusImplRequest XdpDbusImplRequest;
typedef struct _XdpDbusImplRequestIface XdpDbusImplRequestIface;

struct _XdpDbusImplRequestIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_close) (
    XdpDbusImplRequest *object,
    GDBusMethodInvocation *invocation);

};

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

GType xdp_dbus_impl_request_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_request_interface_info (void);
guint xdp_dbus_impl_request_override_properties (GObjectClass *klass, guint property_id_begin);


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



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

gboolean xdp_dbus_impl_request_call_close_finish (
    XdpDbusImplRequest *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_request_call_close_sync (
    XdpDbusImplRequest *proxy,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_DBUS_IMPL_TYPE_REQUEST_PROXY (xdp_dbus_impl_request_proxy_get_type ())
#define XDP_DBUS_IMPL_REQUEST_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_REQUEST_PROXY, XdpDbusImplRequestProxy))
#define XDP_DBUS_IMPL_REQUEST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_REQUEST_PROXY, XdpDbusImplRequestProxyClass))
#define XDP_DBUS_IMPL_REQUEST_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_REQUEST_PROXY, XdpDbusImplRequestProxyClass))
#define XDP_DBUS_IMPL_IS_REQUEST_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_REQUEST_PROXY))
#define XDP_DBUS_IMPL_IS_REQUEST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_REQUEST_PROXY))

typedef struct _XdpDbusImplRequestProxy XdpDbusImplRequestProxy;
typedef struct _XdpDbusImplRequestProxyClass XdpDbusImplRequestProxyClass;
typedef struct _XdpDbusImplRequestProxyPrivate XdpDbusImplRequestProxyPrivate;

struct _XdpDbusImplRequestProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplRequestProxyPrivate *priv;
};

struct _XdpDbusImplRequestProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_request_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_request_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplRequest *xdp_dbus_impl_request_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplRequest *xdp_dbus_impl_request_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_request_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplRequest *xdp_dbus_impl_request_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplRequest *xdp_dbus_impl_request_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_REQUEST_SKELETON (xdp_dbus_impl_request_skeleton_get_type ())
#define XDP_DBUS_IMPL_REQUEST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_REQUEST_SKELETON, XdpDbusImplRequestSkeleton))
#define XDP_DBUS_IMPL_REQUEST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_REQUEST_SKELETON, XdpDbusImplRequestSkeletonClass))
#define XDP_DBUS_IMPL_REQUEST_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_REQUEST_SKELETON, XdpDbusImplRequestSkeletonClass))
#define XDP_DBUS_IMPL_IS_REQUEST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_REQUEST_SKELETON))
#define XDP_DBUS_IMPL_IS_REQUEST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_REQUEST_SKELETON))

typedef struct _XdpDbusImplRequestSkeleton XdpDbusImplRequestSkeleton;
typedef struct _XdpDbusImplRequestSkeletonClass XdpDbusImplRequestSkeletonClass;
typedef struct _XdpDbusImplRequestSkeletonPrivate XdpDbusImplRequestSkeletonPrivate;

struct _XdpDbusImplRequestSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplRequestSkeletonPrivate *priv;
};

struct _XdpDbusImplRequestSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_request_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplRequest *xdp_dbus_impl_request_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.ScreenCast */

#define XDP_DBUS_IMPL_TYPE_SCREEN_CAST (xdp_dbus_impl_screen_cast_get_type ())
#define XDP_DBUS_IMPL_SCREEN_CAST(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SCREEN_CAST, XdpDbusImplScreenCast))
#define XDP_DBUS_IMPL_IS_SCREEN_CAST(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SCREEN_CAST))
#define XDP_DBUS_IMPL_SCREEN_CAST_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_SCREEN_CAST, XdpDbusImplScreenCastIface))

struct _XdpDbusImplScreenCast;
typedef struct _XdpDbusImplScreenCast XdpDbusImplScreenCast;
typedef struct _XdpDbusImplScreenCastIface XdpDbusImplScreenCastIface;

struct _XdpDbusImplScreenCastIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_create_session) (
    XdpDbusImplScreenCast *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

  gboolean (*handle_select_sources) (
    XdpDbusImplScreenCast *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

  gboolean (*handle_start) (
    XdpDbusImplScreenCast *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  guint  (*get_available_cursor_modes) (XdpDbusImplScreenCast *object);

  guint  (*get_available_source_types) (XdpDbusImplScreenCast *object);

  guint  (*get_version) (XdpDbusImplScreenCast *object);

};

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

GType xdp_dbus_impl_screen_cast_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_screen_cast_interface_info (void);
guint xdp_dbus_impl_screen_cast_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_screen_cast_complete_create_session (
    XdpDbusImplScreenCast *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_screen_cast_complete_select_sources (
    XdpDbusImplScreenCast *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_screen_cast_complete_start (
    XdpDbusImplScreenCast *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);



/* D-Bus method calls: */
void xdp_dbus_impl_screen_cast_call_create_session (
    XdpDbusImplScreenCast *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_screen_cast_call_create_session_finish (
    XdpDbusImplScreenCast *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_screen_cast_call_create_session_sync (
    XdpDbusImplScreenCast *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_screen_cast_call_select_sources (
    XdpDbusImplScreenCast *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_screen_cast_call_select_sources_finish (
    XdpDbusImplScreenCast *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_screen_cast_call_select_sources_sync (
    XdpDbusImplScreenCast *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_screen_cast_call_start (
    XdpDbusImplScreenCast *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_screen_cast_call_start_finish (
    XdpDbusImplScreenCast *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_screen_cast_call_start_sync (
    XdpDbusImplScreenCast *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_impl_screen_cast_get_available_source_types (XdpDbusImplScreenCast *object);
void xdp_dbus_impl_screen_cast_set_available_source_types (XdpDbusImplScreenCast *object, guint value);

guint xdp_dbus_impl_screen_cast_get_available_cursor_modes (XdpDbusImplScreenCast *object);
void xdp_dbus_impl_screen_cast_set_available_cursor_modes (XdpDbusImplScreenCast *object, guint value);

guint xdp_dbus_impl_screen_cast_get_version (XdpDbusImplScreenCast *object);
void xdp_dbus_impl_screen_cast_set_version (XdpDbusImplScreenCast *object, guint value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_SCREEN_CAST_PROXY (xdp_dbus_impl_screen_cast_proxy_get_type ())
#define XDP_DBUS_IMPL_SCREEN_CAST_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SCREEN_CAST_PROXY, XdpDbusImplScreenCastProxy))
#define XDP_DBUS_IMPL_SCREEN_CAST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_SCREEN_CAST_PROXY, XdpDbusImplScreenCastProxyClass))
#define XDP_DBUS_IMPL_SCREEN_CAST_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_SCREEN_CAST_PROXY, XdpDbusImplScreenCastProxyClass))
#define XDP_DBUS_IMPL_IS_SCREEN_CAST_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SCREEN_CAST_PROXY))
#define XDP_DBUS_IMPL_IS_SCREEN_CAST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_SCREEN_CAST_PROXY))

typedef struct _XdpDbusImplScreenCastProxy XdpDbusImplScreenCastProxy;
typedef struct _XdpDbusImplScreenCastProxyClass XdpDbusImplScreenCastProxyClass;
typedef struct _XdpDbusImplScreenCastProxyPrivate XdpDbusImplScreenCastProxyPrivate;

struct _XdpDbusImplScreenCastProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplScreenCastProxyPrivate *priv;
};

struct _XdpDbusImplScreenCastProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_screen_cast_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_screen_cast_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplScreenCast *xdp_dbus_impl_screen_cast_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplScreenCast *xdp_dbus_impl_screen_cast_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_screen_cast_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplScreenCast *xdp_dbus_impl_screen_cast_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplScreenCast *xdp_dbus_impl_screen_cast_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_SCREEN_CAST_SKELETON (xdp_dbus_impl_screen_cast_skeleton_get_type ())
#define XDP_DBUS_IMPL_SCREEN_CAST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SCREEN_CAST_SKELETON, XdpDbusImplScreenCastSkeleton))
#define XDP_DBUS_IMPL_SCREEN_CAST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_SCREEN_CAST_SKELETON, XdpDbusImplScreenCastSkeletonClass))
#define XDP_DBUS_IMPL_SCREEN_CAST_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_SCREEN_CAST_SKELETON, XdpDbusImplScreenCastSkeletonClass))
#define XDP_DBUS_IMPL_IS_SCREEN_CAST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SCREEN_CAST_SKELETON))
#define XDP_DBUS_IMPL_IS_SCREEN_CAST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_SCREEN_CAST_SKELETON))

typedef struct _XdpDbusImplScreenCastSkeleton XdpDbusImplScreenCastSkeleton;
typedef struct _XdpDbusImplScreenCastSkeletonClass XdpDbusImplScreenCastSkeletonClass;
typedef struct _XdpDbusImplScreenCastSkeletonPrivate XdpDbusImplScreenCastSkeletonPrivate;

struct _XdpDbusImplScreenCastSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplScreenCastSkeletonPrivate *priv;
};

struct _XdpDbusImplScreenCastSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_screen_cast_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplScreenCast *xdp_dbus_impl_screen_cast_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Screenshot */

#define XDP_DBUS_IMPL_TYPE_SCREENSHOT (xdp_dbus_impl_screenshot_get_type ())
#define XDP_DBUS_IMPL_SCREENSHOT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SCREENSHOT, XdpDbusImplScreenshot))
#define XDP_DBUS_IMPL_IS_SCREENSHOT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SCREENSHOT))
#define XDP_DBUS_IMPL_SCREENSHOT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_SCREENSHOT, XdpDbusImplScreenshotIface))

struct _XdpDbusImplScreenshot;
typedef struct _XdpDbusImplScreenshot XdpDbusImplScreenshot;
typedef struct _XdpDbusImplScreenshotIface XdpDbusImplScreenshotIface;

struct _XdpDbusImplScreenshotIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_pick_color) (
    XdpDbusImplScreenshot *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  gboolean (*handle_screenshot) (
    XdpDbusImplScreenshot *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  guint  (*get_available_targets) (XdpDbusImplScreenshot *object);

  guint  (*get_version) (XdpDbusImplScreenshot *object);

};

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

GType xdp_dbus_impl_screenshot_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_screenshot_interface_info (void);
guint xdp_dbus_impl_screenshot_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_screenshot_complete_screenshot (
    XdpDbusImplScreenshot *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_dbus_impl_screenshot_complete_pick_color (
    XdpDbusImplScreenshot *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);



/* D-Bus method calls: */
void xdp_dbus_impl_screenshot_call_screenshot (
    XdpDbusImplScreenshot *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_screenshot_call_screenshot_finish (
    XdpDbusImplScreenshot *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_screenshot_call_screenshot_sync (
    XdpDbusImplScreenshot *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_screenshot_call_pick_color (
    XdpDbusImplScreenshot *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_screenshot_call_pick_color_finish (
    XdpDbusImplScreenshot *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_screenshot_call_pick_color_sync (
    XdpDbusImplScreenshot *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_impl_screenshot_get_available_targets (XdpDbusImplScreenshot *object);
void xdp_dbus_impl_screenshot_set_available_targets (XdpDbusImplScreenshot *object, guint value);

guint xdp_dbus_impl_screenshot_get_version (XdpDbusImplScreenshot *object);
void xdp_dbus_impl_screenshot_set_version (XdpDbusImplScreenshot *object, guint value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_SCREENSHOT_PROXY (xdp_dbus_impl_screenshot_proxy_get_type ())
#define XDP_DBUS_IMPL_SCREENSHOT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SCREENSHOT_PROXY, XdpDbusImplScreenshotProxy))
#define XDP_DBUS_IMPL_SCREENSHOT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_SCREENSHOT_PROXY, XdpDbusImplScreenshotProxyClass))
#define XDP_DBUS_IMPL_SCREENSHOT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_SCREENSHOT_PROXY, XdpDbusImplScreenshotProxyClass))
#define XDP_DBUS_IMPL_IS_SCREENSHOT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SCREENSHOT_PROXY))
#define XDP_DBUS_IMPL_IS_SCREENSHOT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_SCREENSHOT_PROXY))

typedef struct _XdpDbusImplScreenshotProxy XdpDbusImplScreenshotProxy;
typedef struct _XdpDbusImplScreenshotProxyClass XdpDbusImplScreenshotProxyClass;
typedef struct _XdpDbusImplScreenshotProxyPrivate XdpDbusImplScreenshotProxyPrivate;

struct _XdpDbusImplScreenshotProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplScreenshotProxyPrivate *priv;
};

struct _XdpDbusImplScreenshotProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_screenshot_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_screenshot_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplScreenshot *xdp_dbus_impl_screenshot_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplScreenshot *xdp_dbus_impl_screenshot_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_screenshot_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplScreenshot *xdp_dbus_impl_screenshot_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplScreenshot *xdp_dbus_impl_screenshot_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_SCREENSHOT_SKELETON (xdp_dbus_impl_screenshot_skeleton_get_type ())
#define XDP_DBUS_IMPL_SCREENSHOT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SCREENSHOT_SKELETON, XdpDbusImplScreenshotSkeleton))
#define XDP_DBUS_IMPL_SCREENSHOT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_SCREENSHOT_SKELETON, XdpDbusImplScreenshotSkeletonClass))
#define XDP_DBUS_IMPL_SCREENSHOT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_SCREENSHOT_SKELETON, XdpDbusImplScreenshotSkeletonClass))
#define XDP_DBUS_IMPL_IS_SCREENSHOT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SCREENSHOT_SKELETON))
#define XDP_DBUS_IMPL_IS_SCREENSHOT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_SCREENSHOT_SKELETON))

typedef struct _XdpDbusImplScreenshotSkeleton XdpDbusImplScreenshotSkeleton;
typedef struct _XdpDbusImplScreenshotSkeletonClass XdpDbusImplScreenshotSkeletonClass;
typedef struct _XdpDbusImplScreenshotSkeletonPrivate XdpDbusImplScreenshotSkeletonPrivate;

struct _XdpDbusImplScreenshotSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplScreenshotSkeletonPrivate *priv;
};

struct _XdpDbusImplScreenshotSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_screenshot_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplScreenshot *xdp_dbus_impl_screenshot_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Secret */

#define XDP_DBUS_IMPL_TYPE_SECRET (xdp_dbus_impl_secret_get_type ())
#define XDP_DBUS_IMPL_SECRET(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SECRET, XdpDbusImplSecret))
#define XDP_DBUS_IMPL_IS_SECRET(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SECRET))
#define XDP_DBUS_IMPL_SECRET_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_SECRET, XdpDbusImplSecretIface))

struct _XdpDbusImplSecret;
typedef struct _XdpDbusImplSecret XdpDbusImplSecret;
typedef struct _XdpDbusImplSecretIface XdpDbusImplSecretIface;

struct _XdpDbusImplSecretIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_retrieve_secret) (
    XdpDbusImplSecret *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    GVariant *arg_fd,
    GVariant *arg_options);

  guint  (*get_version) (XdpDbusImplSecret *object);

};

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

GType xdp_dbus_impl_secret_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_secret_interface_info (void);
guint xdp_dbus_impl_secret_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_secret_complete_retrieve_secret (
    XdpDbusImplSecret *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    guint response,
    GVariant *results);



/* D-Bus method calls: */
void xdp_dbus_impl_secret_call_retrieve_secret (
    XdpDbusImplSecret *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_secret_call_retrieve_secret_finish (
    XdpDbusImplSecret *proxy,
    guint* out_response,
    GVariant ** out_results,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_secret_call_retrieve_secret_sync (
    XdpDbusImplSecret *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    guint* out_response,
    GVariant ** out_results,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_impl_secret_get_version (XdpDbusImplSecret *object);
void xdp_dbus_impl_secret_set_version (XdpDbusImplSecret *object, guint value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_SECRET_PROXY (xdp_dbus_impl_secret_proxy_get_type ())
#define XDP_DBUS_IMPL_SECRET_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SECRET_PROXY, XdpDbusImplSecretProxy))
#define XDP_DBUS_IMPL_SECRET_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_SECRET_PROXY, XdpDbusImplSecretProxyClass))
#define XDP_DBUS_IMPL_SECRET_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_SECRET_PROXY, XdpDbusImplSecretProxyClass))
#define XDP_DBUS_IMPL_IS_SECRET_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SECRET_PROXY))
#define XDP_DBUS_IMPL_IS_SECRET_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_SECRET_PROXY))

typedef struct _XdpDbusImplSecretProxy XdpDbusImplSecretProxy;
typedef struct _XdpDbusImplSecretProxyClass XdpDbusImplSecretProxyClass;
typedef struct _XdpDbusImplSecretProxyPrivate XdpDbusImplSecretProxyPrivate;

struct _XdpDbusImplSecretProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplSecretProxyPrivate *priv;
};

struct _XdpDbusImplSecretProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_secret_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_secret_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplSecret *xdp_dbus_impl_secret_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplSecret *xdp_dbus_impl_secret_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_secret_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplSecret *xdp_dbus_impl_secret_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplSecret *xdp_dbus_impl_secret_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_SECRET_SKELETON (xdp_dbus_impl_secret_skeleton_get_type ())
#define XDP_DBUS_IMPL_SECRET_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SECRET_SKELETON, XdpDbusImplSecretSkeleton))
#define XDP_DBUS_IMPL_SECRET_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_SECRET_SKELETON, XdpDbusImplSecretSkeletonClass))
#define XDP_DBUS_IMPL_SECRET_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_SECRET_SKELETON, XdpDbusImplSecretSkeletonClass))
#define XDP_DBUS_IMPL_IS_SECRET_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SECRET_SKELETON))
#define XDP_DBUS_IMPL_IS_SECRET_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_SECRET_SKELETON))

typedef struct _XdpDbusImplSecretSkeleton XdpDbusImplSecretSkeleton;
typedef struct _XdpDbusImplSecretSkeletonClass XdpDbusImplSecretSkeletonClass;
typedef struct _XdpDbusImplSecretSkeletonPrivate XdpDbusImplSecretSkeletonPrivate;

struct _XdpDbusImplSecretSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplSecretSkeletonPrivate *priv;
};

struct _XdpDbusImplSecretSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_secret_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplSecret *xdp_dbus_impl_secret_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Session */

#define XDP_DBUS_IMPL_TYPE_SESSION (xdp_dbus_impl_session_get_type ())
#define XDP_DBUS_IMPL_SESSION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SESSION, XdpDbusImplSession))
#define XDP_DBUS_IMPL_IS_SESSION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SESSION))
#define XDP_DBUS_IMPL_SESSION_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_SESSION, XdpDbusImplSessionIface))

struct _XdpDbusImplSession;
typedef struct _XdpDbusImplSession XdpDbusImplSession;
typedef struct _XdpDbusImplSessionIface XdpDbusImplSessionIface;

struct _XdpDbusImplSessionIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_close) (
    XdpDbusImplSession *object,
    GDBusMethodInvocation *invocation);

  guint  (*get_version) (XdpDbusImplSession *object);

  void (*closed) (
    XdpDbusImplSession *object);

};

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

GType xdp_dbus_impl_session_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_session_interface_info (void);
guint xdp_dbus_impl_session_override_properties (GObjectClass *klass, guint property_id_begin);


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



/* D-Bus signal emissions functions: */
void xdp_dbus_impl_session_emit_closed (
    XdpDbusImplSession *object);



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

gboolean xdp_dbus_impl_session_call_close_finish (
    XdpDbusImplSession *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_session_call_close_sync (
    XdpDbusImplSession *proxy,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_impl_session_get_version (XdpDbusImplSession *object);
void xdp_dbus_impl_session_set_version (XdpDbusImplSession *object, guint value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_SESSION_PROXY (xdp_dbus_impl_session_proxy_get_type ())
#define XDP_DBUS_IMPL_SESSION_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SESSION_PROXY, XdpDbusImplSessionProxy))
#define XDP_DBUS_IMPL_SESSION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_SESSION_PROXY, XdpDbusImplSessionProxyClass))
#define XDP_DBUS_IMPL_SESSION_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_SESSION_PROXY, XdpDbusImplSessionProxyClass))
#define XDP_DBUS_IMPL_IS_SESSION_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SESSION_PROXY))
#define XDP_DBUS_IMPL_IS_SESSION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_SESSION_PROXY))

typedef struct _XdpDbusImplSessionProxy XdpDbusImplSessionProxy;
typedef struct _XdpDbusImplSessionProxyClass XdpDbusImplSessionProxyClass;
typedef struct _XdpDbusImplSessionProxyPrivate XdpDbusImplSessionProxyPrivate;

struct _XdpDbusImplSessionProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplSessionProxyPrivate *priv;
};

struct _XdpDbusImplSessionProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_session_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_session_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplSession *xdp_dbus_impl_session_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplSession *xdp_dbus_impl_session_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_session_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplSession *xdp_dbus_impl_session_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplSession *xdp_dbus_impl_session_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_SESSION_SKELETON (xdp_dbus_impl_session_skeleton_get_type ())
#define XDP_DBUS_IMPL_SESSION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SESSION_SKELETON, XdpDbusImplSessionSkeleton))
#define XDP_DBUS_IMPL_SESSION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_SESSION_SKELETON, XdpDbusImplSessionSkeletonClass))
#define XDP_DBUS_IMPL_SESSION_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_SESSION_SKELETON, XdpDbusImplSessionSkeletonClass))
#define XDP_DBUS_IMPL_IS_SESSION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SESSION_SKELETON))
#define XDP_DBUS_IMPL_IS_SESSION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_SESSION_SKELETON))

typedef struct _XdpDbusImplSessionSkeleton XdpDbusImplSessionSkeleton;
typedef struct _XdpDbusImplSessionSkeletonClass XdpDbusImplSessionSkeletonClass;
typedef struct _XdpDbusImplSessionSkeletonPrivate XdpDbusImplSessionSkeletonPrivate;

struct _XdpDbusImplSessionSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplSessionSkeletonPrivate *priv;
};

struct _XdpDbusImplSessionSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_session_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplSession *xdp_dbus_impl_session_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Settings */

#define XDP_DBUS_IMPL_TYPE_SETTINGS (xdp_dbus_impl_settings_get_type ())
#define XDP_DBUS_IMPL_SETTINGS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SETTINGS, XdpDbusImplSettings))
#define XDP_DBUS_IMPL_IS_SETTINGS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SETTINGS))
#define XDP_DBUS_IMPL_SETTINGS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_SETTINGS, XdpDbusImplSettingsIface))

struct _XdpDbusImplSettings;
typedef struct _XdpDbusImplSettings XdpDbusImplSettings;
typedef struct _XdpDbusImplSettingsIface XdpDbusImplSettingsIface;

struct _XdpDbusImplSettingsIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_read) (
    XdpDbusImplSettings *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_namespace,
    const gchar *arg_key);

  gboolean (*handle_read_all) (
    XdpDbusImplSettings *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *arg_namespaces);

  guint  (*get_version) (XdpDbusImplSettings *object);

  void (*setting_changed) (
    XdpDbusImplSettings *object,
    const gchar *arg_namespace,
    const gchar *arg_key,
    GVariant *arg_value);

};

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

GType xdp_dbus_impl_settings_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_settings_interface_info (void);
guint xdp_dbus_impl_settings_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_settings_complete_read_all (
    XdpDbusImplSettings *object,
    GDBusMethodInvocation *invocation,
    GVariant *value);

void xdp_dbus_impl_settings_complete_read (
    XdpDbusImplSettings *object,
    GDBusMethodInvocation *invocation,
    GVariant *value);



/* D-Bus signal emissions functions: */
void xdp_dbus_impl_settings_emit_setting_changed (
    XdpDbusImplSettings *object,
    const gchar *arg_namespace,
    const gchar *arg_key,
    GVariant *arg_value);



/* D-Bus method calls: */
void xdp_dbus_impl_settings_call_read_all (
    XdpDbusImplSettings *proxy,
    const gchar *const *arg_namespaces,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_settings_call_read_all_finish (
    XdpDbusImplSettings *proxy,
    GVariant ** out_value,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_settings_call_read_all_sync (
    XdpDbusImplSettings *proxy,
    const gchar *const *arg_namespaces,
    GVariant ** out_value,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_impl_settings_call_read (
    XdpDbusImplSettings *proxy,
    const gchar *arg_namespace,
    const gchar *arg_key,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_settings_call_read_finish (
    XdpDbusImplSettings *proxy,
    GVariant ** out_value,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_settings_call_read_sync (
    XdpDbusImplSettings *proxy,
    const gchar *arg_namespace,
    const gchar *arg_key,
    GVariant ** out_value,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_impl_settings_get_version (XdpDbusImplSettings *object);
void xdp_dbus_impl_settings_set_version (XdpDbusImplSettings *object, guint value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_SETTINGS_PROXY (xdp_dbus_impl_settings_proxy_get_type ())
#define XDP_DBUS_IMPL_SETTINGS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SETTINGS_PROXY, XdpDbusImplSettingsProxy))
#define XDP_DBUS_IMPL_SETTINGS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_SETTINGS_PROXY, XdpDbusImplSettingsProxyClass))
#define XDP_DBUS_IMPL_SETTINGS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_SETTINGS_PROXY, XdpDbusImplSettingsProxyClass))
#define XDP_DBUS_IMPL_IS_SETTINGS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SETTINGS_PROXY))
#define XDP_DBUS_IMPL_IS_SETTINGS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_SETTINGS_PROXY))

typedef struct _XdpDbusImplSettingsProxy XdpDbusImplSettingsProxy;
typedef struct _XdpDbusImplSettingsProxyClass XdpDbusImplSettingsProxyClass;
typedef struct _XdpDbusImplSettingsProxyPrivate XdpDbusImplSettingsProxyPrivate;

struct _XdpDbusImplSettingsProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplSettingsProxyPrivate *priv;
};

struct _XdpDbusImplSettingsProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_settings_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_settings_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplSettings *xdp_dbus_impl_settings_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplSettings *xdp_dbus_impl_settings_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_settings_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplSettings *xdp_dbus_impl_settings_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplSettings *xdp_dbus_impl_settings_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_SETTINGS_SKELETON (xdp_dbus_impl_settings_skeleton_get_type ())
#define XDP_DBUS_IMPL_SETTINGS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_SETTINGS_SKELETON, XdpDbusImplSettingsSkeleton))
#define XDP_DBUS_IMPL_SETTINGS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_SETTINGS_SKELETON, XdpDbusImplSettingsSkeletonClass))
#define XDP_DBUS_IMPL_SETTINGS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_SETTINGS_SKELETON, XdpDbusImplSettingsSkeletonClass))
#define XDP_DBUS_IMPL_IS_SETTINGS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_SETTINGS_SKELETON))
#define XDP_DBUS_IMPL_IS_SETTINGS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_SETTINGS_SKELETON))

typedef struct _XdpDbusImplSettingsSkeleton XdpDbusImplSettingsSkeleton;
typedef struct _XdpDbusImplSettingsSkeletonClass XdpDbusImplSettingsSkeletonClass;
typedef struct _XdpDbusImplSettingsSkeletonPrivate XdpDbusImplSettingsSkeletonPrivate;

struct _XdpDbusImplSettingsSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplSettingsSkeletonPrivate *priv;
};

struct _XdpDbusImplSettingsSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_settings_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplSettings *xdp_dbus_impl_settings_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Usb */

#define XDP_DBUS_IMPL_TYPE_USB (xdp_dbus_impl_usb_get_type ())
#define XDP_DBUS_IMPL_USB(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_USB, XdpDbusImplUsb))
#define XDP_DBUS_IMPL_IS_USB(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_USB))
#define XDP_DBUS_IMPL_USB_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_USB, XdpDbusImplUsbIface))

struct _XdpDbusImplUsb;
typedef struct _XdpDbusImplUsb XdpDbusImplUsb;
typedef struct _XdpDbusImplUsbIface XdpDbusImplUsbIface;

struct _XdpDbusImplUsbIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_acquire_devices) (
    XdpDbusImplUsb *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_parent_window,
    const gchar *arg_app_id,
    GVariant *arg_devices,
    GVariant *arg_options);

  guint  (*get_version) (XdpDbusImplUsb *object);

};

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

GType xdp_dbus_impl_usb_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_usb_interface_info (void);
guint xdp_dbus_impl_usb_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_usb_complete_acquire_devices (
    XdpDbusImplUsb *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);



/* D-Bus method calls: */
void xdp_dbus_impl_usb_call_acquire_devices (
    XdpDbusImplUsb *proxy,
    const gchar *arg_handle,
    const gchar *arg_parent_window,
    const gchar *arg_app_id,
    GVariant *arg_devices,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_usb_call_acquire_devices_finish (
    XdpDbusImplUsb *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_usb_call_acquire_devices_sync (
    XdpDbusImplUsb *proxy,
    const gchar *arg_handle,
    const gchar *arg_parent_window,
    const gchar *arg_app_id,
    GVariant *arg_devices,
    GVariant *arg_options,
    guint* out_response,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_impl_usb_get_version (XdpDbusImplUsb *object);
void xdp_dbus_impl_usb_set_version (XdpDbusImplUsb *object, guint value);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_USB_PROXY (xdp_dbus_impl_usb_proxy_get_type ())
#define XDP_DBUS_IMPL_USB_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_USB_PROXY, XdpDbusImplUsbProxy))
#define XDP_DBUS_IMPL_USB_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_USB_PROXY, XdpDbusImplUsbProxyClass))
#define XDP_DBUS_IMPL_USB_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_USB_PROXY, XdpDbusImplUsbProxyClass))
#define XDP_DBUS_IMPL_IS_USB_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_USB_PROXY))
#define XDP_DBUS_IMPL_IS_USB_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_USB_PROXY))

typedef struct _XdpDbusImplUsbProxy XdpDbusImplUsbProxy;
typedef struct _XdpDbusImplUsbProxyClass XdpDbusImplUsbProxyClass;
typedef struct _XdpDbusImplUsbProxyPrivate XdpDbusImplUsbProxyPrivate;

struct _XdpDbusImplUsbProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplUsbProxyPrivate *priv;
};

struct _XdpDbusImplUsbProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_usb_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_usb_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplUsb *xdp_dbus_impl_usb_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplUsb *xdp_dbus_impl_usb_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_usb_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplUsb *xdp_dbus_impl_usb_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplUsb *xdp_dbus_impl_usb_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_USB_SKELETON (xdp_dbus_impl_usb_skeleton_get_type ())
#define XDP_DBUS_IMPL_USB_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_USB_SKELETON, XdpDbusImplUsbSkeleton))
#define XDP_DBUS_IMPL_USB_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_USB_SKELETON, XdpDbusImplUsbSkeletonClass))
#define XDP_DBUS_IMPL_USB_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_USB_SKELETON, XdpDbusImplUsbSkeletonClass))
#define XDP_DBUS_IMPL_IS_USB_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_USB_SKELETON))
#define XDP_DBUS_IMPL_IS_USB_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_USB_SKELETON))

typedef struct _XdpDbusImplUsbSkeleton XdpDbusImplUsbSkeleton;
typedef struct _XdpDbusImplUsbSkeletonClass XdpDbusImplUsbSkeletonClass;
typedef struct _XdpDbusImplUsbSkeletonPrivate XdpDbusImplUsbSkeletonPrivate;

struct _XdpDbusImplUsbSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplUsbSkeletonPrivate *priv;
};

struct _XdpDbusImplUsbSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_usb_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplUsb *xdp_dbus_impl_usb_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.impl.portal.Wallpaper */

#define XDP_DBUS_IMPL_TYPE_WALLPAPER (xdp_dbus_impl_wallpaper_get_type ())
#define XDP_DBUS_IMPL_WALLPAPER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_WALLPAPER, XdpDbusImplWallpaper))
#define XDP_DBUS_IMPL_IS_WALLPAPER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_WALLPAPER))
#define XDP_DBUS_IMPL_WALLPAPER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_IMPL_TYPE_WALLPAPER, XdpDbusImplWallpaperIface))

struct _XdpDbusImplWallpaper;
typedef struct _XdpDbusImplWallpaper XdpDbusImplWallpaper;
typedef struct _XdpDbusImplWallpaperIface XdpDbusImplWallpaperIface;

struct _XdpDbusImplWallpaperIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_set_wallpaper_uri) (
    XdpDbusImplWallpaper *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_uri,
    GVariant *arg_options);

};

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

GType xdp_dbus_impl_wallpaper_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_impl_wallpaper_interface_info (void);
guint xdp_dbus_impl_wallpaper_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_impl_wallpaper_complete_set_wallpaper_uri (
    XdpDbusImplWallpaper *object,
    GDBusMethodInvocation *invocation,
    guint response);



/* D-Bus method calls: */
void xdp_dbus_impl_wallpaper_call_set_wallpaper_uri (
    XdpDbusImplWallpaper *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_uri,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_impl_wallpaper_call_set_wallpaper_uri_finish (
    XdpDbusImplWallpaper *proxy,
    guint* out_response,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_impl_wallpaper_call_set_wallpaper_uri_sync (
    XdpDbusImplWallpaper *proxy,
    const gchar *arg_handle,
    const gchar *arg_app_id,
    const gchar *arg_parent_window,
    const gchar *arg_uri,
    GVariant *arg_options,
    guint* out_response,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_DBUS_IMPL_TYPE_WALLPAPER_PROXY (xdp_dbus_impl_wallpaper_proxy_get_type ())
#define XDP_DBUS_IMPL_WALLPAPER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_WALLPAPER_PROXY, XdpDbusImplWallpaperProxy))
#define XDP_DBUS_IMPL_WALLPAPER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_WALLPAPER_PROXY, XdpDbusImplWallpaperProxyClass))
#define XDP_DBUS_IMPL_WALLPAPER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_WALLPAPER_PROXY, XdpDbusImplWallpaperProxyClass))
#define XDP_DBUS_IMPL_IS_WALLPAPER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_WALLPAPER_PROXY))
#define XDP_DBUS_IMPL_IS_WALLPAPER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_WALLPAPER_PROXY))

typedef struct _XdpDbusImplWallpaperProxy XdpDbusImplWallpaperProxy;
typedef struct _XdpDbusImplWallpaperProxyClass XdpDbusImplWallpaperProxyClass;
typedef struct _XdpDbusImplWallpaperProxyPrivate XdpDbusImplWallpaperProxyPrivate;

struct _XdpDbusImplWallpaperProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusImplWallpaperProxyPrivate *priv;
};

struct _XdpDbusImplWallpaperProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_impl_wallpaper_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_impl_wallpaper_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplWallpaper *xdp_dbus_impl_wallpaper_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplWallpaper *xdp_dbus_impl_wallpaper_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_impl_wallpaper_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusImplWallpaper *xdp_dbus_impl_wallpaper_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusImplWallpaper *xdp_dbus_impl_wallpaper_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_IMPL_TYPE_WALLPAPER_SKELETON (xdp_dbus_impl_wallpaper_skeleton_get_type ())
#define XDP_DBUS_IMPL_WALLPAPER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_IMPL_TYPE_WALLPAPER_SKELETON, XdpDbusImplWallpaperSkeleton))
#define XDP_DBUS_IMPL_WALLPAPER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_IMPL_TYPE_WALLPAPER_SKELETON, XdpDbusImplWallpaperSkeletonClass))
#define XDP_DBUS_IMPL_WALLPAPER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_IMPL_TYPE_WALLPAPER_SKELETON, XdpDbusImplWallpaperSkeletonClass))
#define XDP_DBUS_IMPL_IS_WALLPAPER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_IMPL_TYPE_WALLPAPER_SKELETON))
#define XDP_DBUS_IMPL_IS_WALLPAPER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_IMPL_TYPE_WALLPAPER_SKELETON))

typedef struct _XdpDbusImplWallpaperSkeleton XdpDbusImplWallpaperSkeleton;
typedef struct _XdpDbusImplWallpaperSkeletonClass XdpDbusImplWallpaperSkeletonClass;
typedef struct _XdpDbusImplWallpaperSkeletonPrivate XdpDbusImplWallpaperSkeletonPrivate;

struct _XdpDbusImplWallpaperSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusImplWallpaperSkeletonPrivate *priv;
};

struct _XdpDbusImplWallpaperSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_impl_wallpaper_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusImplWallpaper *xdp_dbus_impl_wallpaper_skeleton_new (void);


G_END_DECLS

#endif /* __XDP_IMPL_DBUS_H__ */
