/*
 * 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 __XDG_DESKTOP_PORTAL_DBUS_H__
#define __XDG_DESKTOP_PORTAL_DBUS_H__

#include <gio/gio.h>

G_BEGIN_DECLS


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

#define XDP_IMPL_TYPE_ACCESS (xdp_impl_access_get_type ())
#define XDP_IMPL_ACCESS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_ACCESS, XdpImplAccess))
#define XDP_IMPL_IS_ACCESS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_ACCESS))
#define XDP_IMPL_ACCESS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_ACCESS, XdpImplAccessIface))

struct _XdpImplAccess;
typedef struct _XdpImplAccess XdpImplAccess;
typedef struct _XdpImplAccessIface XdpImplAccessIface;

struct _XdpImplAccessIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_access_dialog) (
    XdpImplAccess *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 (XdpImplAccess, g_object_unref)
#endif

GType xdp_impl_access_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_access_interface_info (void);
guint xdp_impl_access_override_properties (GObjectClass *klass, guint property_id_begin);


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



/* D-Bus method calls: */
void xdp_impl_access_call_access_dialog (
    XdpImplAccess *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_impl_access_call_access_dialog_finish (
    XdpImplAccess *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_access_call_access_dialog_sync (
    XdpImplAccess *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_IMPL_TYPE_ACCESS_PROXY (xdp_impl_access_proxy_get_type ())
#define XDP_IMPL_ACCESS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_ACCESS_PROXY, XdpImplAccessProxy))
#define XDP_IMPL_ACCESS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_ACCESS_PROXY, XdpImplAccessProxyClass))
#define XDP_IMPL_ACCESS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_ACCESS_PROXY, XdpImplAccessProxyClass))
#define XDP_IMPL_IS_ACCESS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_ACCESS_PROXY))
#define XDP_IMPL_IS_ACCESS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_ACCESS_PROXY))

typedef struct _XdpImplAccessProxy XdpImplAccessProxy;
typedef struct _XdpImplAccessProxyClass XdpImplAccessProxyClass;
typedef struct _XdpImplAccessProxyPrivate XdpImplAccessProxyPrivate;

struct _XdpImplAccessProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplAccessProxyPrivate *priv;
};

struct _XdpImplAccessProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_access_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_access_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplAccess *xdp_impl_access_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplAccess *xdp_impl_access_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplAccess *xdp_impl_access_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplAccess *xdp_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_IMPL_TYPE_ACCESS_SKELETON (xdp_impl_access_skeleton_get_type ())
#define XDP_IMPL_ACCESS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_ACCESS_SKELETON, XdpImplAccessSkeleton))
#define XDP_IMPL_ACCESS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_ACCESS_SKELETON, XdpImplAccessSkeletonClass))
#define XDP_IMPL_ACCESS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_ACCESS_SKELETON, XdpImplAccessSkeletonClass))
#define XDP_IMPL_IS_ACCESS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_ACCESS_SKELETON))
#define XDP_IMPL_IS_ACCESS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_ACCESS_SKELETON))

typedef struct _XdpImplAccessSkeleton XdpImplAccessSkeleton;
typedef struct _XdpImplAccessSkeletonClass XdpImplAccessSkeletonClass;
typedef struct _XdpImplAccessSkeletonPrivate XdpImplAccessSkeletonPrivate;

struct _XdpImplAccessSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplAccessSkeletonPrivate *priv;
};

struct _XdpImplAccessSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_access_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplAccess *xdp_impl_access_skeleton_new (void);


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

#define XDP_IMPL_TYPE_ACCOUNT (xdp_impl_account_get_type ())
#define XDP_IMPL_ACCOUNT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_ACCOUNT, XdpImplAccount))
#define XDP_IMPL_IS_ACCOUNT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_ACCOUNT))
#define XDP_IMPL_ACCOUNT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_ACCOUNT, XdpImplAccountIface))

struct _XdpImplAccount;
typedef struct _XdpImplAccount XdpImplAccount;
typedef struct _XdpImplAccountIface XdpImplAccountIface;

struct _XdpImplAccountIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_get_user_information) (
    XdpImplAccount *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 (XdpImplAccount, g_object_unref)
#endif

GType xdp_impl_account_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_account_interface_info (void);
guint xdp_impl_account_override_properties (GObjectClass *klass, guint property_id_begin);


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



/* D-Bus method calls: */
void xdp_impl_account_call_get_user_information (
    XdpImplAccount *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_impl_account_call_get_user_information_finish (
    XdpImplAccount *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_account_call_get_user_information_sync (
    XdpImplAccount *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_IMPL_TYPE_ACCOUNT_PROXY (xdp_impl_account_proxy_get_type ())
#define XDP_IMPL_ACCOUNT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_ACCOUNT_PROXY, XdpImplAccountProxy))
#define XDP_IMPL_ACCOUNT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_ACCOUNT_PROXY, XdpImplAccountProxyClass))
#define XDP_IMPL_ACCOUNT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_ACCOUNT_PROXY, XdpImplAccountProxyClass))
#define XDP_IMPL_IS_ACCOUNT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_ACCOUNT_PROXY))
#define XDP_IMPL_IS_ACCOUNT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_ACCOUNT_PROXY))

typedef struct _XdpImplAccountProxy XdpImplAccountProxy;
typedef struct _XdpImplAccountProxyClass XdpImplAccountProxyClass;
typedef struct _XdpImplAccountProxyPrivate XdpImplAccountProxyPrivate;

struct _XdpImplAccountProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplAccountProxyPrivate *priv;
};

struct _XdpImplAccountProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_account_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_account_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplAccount *xdp_impl_account_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplAccount *xdp_impl_account_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplAccount *xdp_impl_account_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplAccount *xdp_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_IMPL_TYPE_ACCOUNT_SKELETON (xdp_impl_account_skeleton_get_type ())
#define XDP_IMPL_ACCOUNT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_ACCOUNT_SKELETON, XdpImplAccountSkeleton))
#define XDP_IMPL_ACCOUNT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_ACCOUNT_SKELETON, XdpImplAccountSkeletonClass))
#define XDP_IMPL_ACCOUNT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_ACCOUNT_SKELETON, XdpImplAccountSkeletonClass))
#define XDP_IMPL_IS_ACCOUNT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_ACCOUNT_SKELETON))
#define XDP_IMPL_IS_ACCOUNT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_ACCOUNT_SKELETON))

typedef struct _XdpImplAccountSkeleton XdpImplAccountSkeleton;
typedef struct _XdpImplAccountSkeletonClass XdpImplAccountSkeletonClass;
typedef struct _XdpImplAccountSkeletonPrivate XdpImplAccountSkeletonPrivate;

struct _XdpImplAccountSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplAccountSkeletonPrivate *priv;
};

struct _XdpImplAccountSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_account_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplAccount *xdp_impl_account_skeleton_new (void);


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

#define XDP_IMPL_TYPE_APP_CHOOSER (xdp_impl_app_chooser_get_type ())
#define XDP_IMPL_APP_CHOOSER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_APP_CHOOSER, XdpImplAppChooser))
#define XDP_IMPL_IS_APP_CHOOSER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_APP_CHOOSER))
#define XDP_IMPL_APP_CHOOSER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_APP_CHOOSER, XdpImplAppChooserIface))

struct _XdpImplAppChooser;
typedef struct _XdpImplAppChooser XdpImplAppChooser;
typedef struct _XdpImplAppChooserIface XdpImplAppChooserIface;

struct _XdpImplAppChooserIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_choose_application) (
    XdpImplAppChooser *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) (
    XdpImplAppChooser *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *const *arg_choices);

};

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

GType xdp_impl_app_chooser_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_app_chooser_interface_info (void);
guint xdp_impl_app_chooser_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_app_chooser_complete_update_choices (
    XdpImplAppChooser *object,
    GDBusMethodInvocation *invocation);



/* D-Bus method calls: */
void xdp_impl_app_chooser_call_choose_application (
    XdpImplAppChooser *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_impl_app_chooser_call_choose_application_finish (
    XdpImplAppChooser *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_app_chooser_call_choose_application_sync (
    XdpImplAppChooser *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_impl_app_chooser_call_update_choices (
    XdpImplAppChooser *proxy,
    const gchar *arg_handle,
    const gchar *const *arg_choices,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_impl_app_chooser_call_update_choices_finish (
    XdpImplAppChooser *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_app_chooser_call_update_choices_sync (
    XdpImplAppChooser *proxy,
    const gchar *arg_handle,
    const gchar *const *arg_choices,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_IMPL_TYPE_APP_CHOOSER_PROXY (xdp_impl_app_chooser_proxy_get_type ())
#define XDP_IMPL_APP_CHOOSER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_APP_CHOOSER_PROXY, XdpImplAppChooserProxy))
#define XDP_IMPL_APP_CHOOSER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_APP_CHOOSER_PROXY, XdpImplAppChooserProxyClass))
#define XDP_IMPL_APP_CHOOSER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_APP_CHOOSER_PROXY, XdpImplAppChooserProxyClass))
#define XDP_IMPL_IS_APP_CHOOSER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_APP_CHOOSER_PROXY))
#define XDP_IMPL_IS_APP_CHOOSER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_APP_CHOOSER_PROXY))

typedef struct _XdpImplAppChooserProxy XdpImplAppChooserProxy;
typedef struct _XdpImplAppChooserProxyClass XdpImplAppChooserProxyClass;
typedef struct _XdpImplAppChooserProxyPrivate XdpImplAppChooserProxyPrivate;

struct _XdpImplAppChooserProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplAppChooserProxyPrivate *priv;
};

struct _XdpImplAppChooserProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_app_chooser_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_app_chooser_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplAppChooser *xdp_impl_app_chooser_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplAppChooser *xdp_impl_app_chooser_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplAppChooser *xdp_impl_app_chooser_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplAppChooser *xdp_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_IMPL_TYPE_APP_CHOOSER_SKELETON (xdp_impl_app_chooser_skeleton_get_type ())
#define XDP_IMPL_APP_CHOOSER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_APP_CHOOSER_SKELETON, XdpImplAppChooserSkeleton))
#define XDP_IMPL_APP_CHOOSER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_APP_CHOOSER_SKELETON, XdpImplAppChooserSkeletonClass))
#define XDP_IMPL_APP_CHOOSER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_APP_CHOOSER_SKELETON, XdpImplAppChooserSkeletonClass))
#define XDP_IMPL_IS_APP_CHOOSER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_APP_CHOOSER_SKELETON))
#define XDP_IMPL_IS_APP_CHOOSER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_APP_CHOOSER_SKELETON))

typedef struct _XdpImplAppChooserSkeleton XdpImplAppChooserSkeleton;
typedef struct _XdpImplAppChooserSkeletonClass XdpImplAppChooserSkeletonClass;
typedef struct _XdpImplAppChooserSkeletonPrivate XdpImplAppChooserSkeletonPrivate;

struct _XdpImplAppChooserSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplAppChooserSkeletonPrivate *priv;
};

struct _XdpImplAppChooserSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_app_chooser_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplAppChooser *xdp_impl_app_chooser_skeleton_new (void);


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

#define XDP_IMPL_TYPE_BACKGROUND (xdp_impl_background_get_type ())
#define XDP_IMPL_BACKGROUND(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_BACKGROUND, XdpImplBackground))
#define XDP_IMPL_IS_BACKGROUND(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_BACKGROUND))
#define XDP_IMPL_BACKGROUND_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_BACKGROUND, XdpImplBackgroundIface))

struct _XdpImplBackground;
typedef struct _XdpImplBackground XdpImplBackground;
typedef struct _XdpImplBackgroundIface XdpImplBackgroundIface;

struct _XdpImplBackgroundIface
{
  GTypeInterface parent_iface;


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

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

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

  void (*running_applications_changed) (
    XdpImplBackground *object);

};

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

GType xdp_impl_background_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_background_interface_info (void);
guint xdp_impl_background_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_background_complete_notify_background (
    XdpImplBackground *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_impl_background_complete_enable_autostart (
    XdpImplBackground *object,
    GDBusMethodInvocation *invocation,
    gboolean result);



/* D-Bus signal emissions functions: */
void xdp_impl_background_emit_running_applications_changed (
    XdpImplBackground *object);



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

gboolean xdp_impl_background_call_get_app_state_finish (
    XdpImplBackground *proxy,
    GVariant ** out_apps,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_background_call_get_app_state_sync (
    XdpImplBackground *proxy,
    GVariant ** out_apps,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_impl_background_call_notify_background_finish (
    XdpImplBackground *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_background_call_notify_background_sync (
    XdpImplBackground *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_impl_background_call_enable_autostart (
    XdpImplBackground *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_impl_background_call_enable_autostart_finish (
    XdpImplBackground *proxy,
    gboolean* out_result,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_background_call_enable_autostart_sync (
    XdpImplBackground *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_IMPL_TYPE_BACKGROUND_PROXY (xdp_impl_background_proxy_get_type ())
#define XDP_IMPL_BACKGROUND_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_BACKGROUND_PROXY, XdpImplBackgroundProxy))
#define XDP_IMPL_BACKGROUND_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_BACKGROUND_PROXY, XdpImplBackgroundProxyClass))
#define XDP_IMPL_BACKGROUND_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_BACKGROUND_PROXY, XdpImplBackgroundProxyClass))
#define XDP_IMPL_IS_BACKGROUND_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_BACKGROUND_PROXY))
#define XDP_IMPL_IS_BACKGROUND_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_BACKGROUND_PROXY))

typedef struct _XdpImplBackgroundProxy XdpImplBackgroundProxy;
typedef struct _XdpImplBackgroundProxyClass XdpImplBackgroundProxyClass;
typedef struct _XdpImplBackgroundProxyPrivate XdpImplBackgroundProxyPrivate;

struct _XdpImplBackgroundProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplBackgroundProxyPrivate *priv;
};

struct _XdpImplBackgroundProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_background_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_background_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplBackground *xdp_impl_background_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplBackground *xdp_impl_background_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplBackground *xdp_impl_background_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplBackground *xdp_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_IMPL_TYPE_BACKGROUND_SKELETON (xdp_impl_background_skeleton_get_type ())
#define XDP_IMPL_BACKGROUND_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_BACKGROUND_SKELETON, XdpImplBackgroundSkeleton))
#define XDP_IMPL_BACKGROUND_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_BACKGROUND_SKELETON, XdpImplBackgroundSkeletonClass))
#define XDP_IMPL_BACKGROUND_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_BACKGROUND_SKELETON, XdpImplBackgroundSkeletonClass))
#define XDP_IMPL_IS_BACKGROUND_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_BACKGROUND_SKELETON))
#define XDP_IMPL_IS_BACKGROUND_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_BACKGROUND_SKELETON))

typedef struct _XdpImplBackgroundSkeleton XdpImplBackgroundSkeleton;
typedef struct _XdpImplBackgroundSkeletonClass XdpImplBackgroundSkeletonClass;
typedef struct _XdpImplBackgroundSkeletonPrivate XdpImplBackgroundSkeletonPrivate;

struct _XdpImplBackgroundSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplBackgroundSkeletonPrivate *priv;
};

struct _XdpImplBackgroundSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_background_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplBackground *xdp_impl_background_skeleton_new (void);


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

#define XDP_IMPL_TYPE_CLIPBOARD (xdp_impl_clipboard_get_type ())
#define XDP_IMPL_CLIPBOARD(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_CLIPBOARD, XdpImplClipboard))
#define XDP_IMPL_IS_CLIPBOARD(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_CLIPBOARD))
#define XDP_IMPL_CLIPBOARD_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_CLIPBOARD, XdpImplClipboardIface))

struct _XdpImplClipboard;
typedef struct _XdpImplClipboard XdpImplClipboard;
typedef struct _XdpImplClipboardIface XdpImplClipboardIface;

struct _XdpImplClipboardIface
{
  GTypeInterface parent_iface;



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

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

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

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

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

  guint  (*get_version) (XdpImplClipboard *object);

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

  void (*selection_transfer) (
    XdpImplClipboard *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 (XdpImplClipboard, g_object_unref)
#endif

GType xdp_impl_clipboard_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_clipboard_interface_info (void);
guint xdp_impl_clipboard_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_clipboard_complete_set_selection (
    XdpImplClipboard *object,
    GDBusMethodInvocation *invocation);

void xdp_impl_clipboard_complete_selection_write (
    XdpImplClipboard *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);

void xdp_impl_clipboard_complete_selection_write_done (
    XdpImplClipboard *object,
    GDBusMethodInvocation *invocation);

void xdp_impl_clipboard_complete_selection_read (
    XdpImplClipboard *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);



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

void xdp_impl_clipboard_emit_selection_transfer (
    XdpImplClipboard *object,
    const gchar *arg_session_handle,
    const gchar *arg_mime_type,
    guint arg_serial);



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

gboolean xdp_impl_clipboard_call_request_clipboard_finish (
    XdpImplClipboard *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_impl_clipboard_call_set_selection_finish (
    XdpImplClipboard *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_impl_clipboard_call_selection_write_finish (
    XdpImplClipboard *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_clipboard_call_selection_write_sync (
    XdpImplClipboard *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_impl_clipboard_call_selection_write_done (
    XdpImplClipboard *proxy,
    const gchar *arg_session_handle,
    guint arg_serial,
    gboolean arg_success,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_impl_clipboard_call_selection_write_done_finish (
    XdpImplClipboard *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_impl_clipboard_call_selection_read_finish (
    XdpImplClipboard *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_clipboard_call_selection_read_sync (
    XdpImplClipboard *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_impl_clipboard_get_version (XdpImplClipboard *object);
void xdp_impl_clipboard_set_version (XdpImplClipboard *object, guint value);


/* ---- */

#define XDP_IMPL_TYPE_CLIPBOARD_PROXY (xdp_impl_clipboard_proxy_get_type ())
#define XDP_IMPL_CLIPBOARD_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_CLIPBOARD_PROXY, XdpImplClipboardProxy))
#define XDP_IMPL_CLIPBOARD_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_CLIPBOARD_PROXY, XdpImplClipboardProxyClass))
#define XDP_IMPL_CLIPBOARD_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_CLIPBOARD_PROXY, XdpImplClipboardProxyClass))
#define XDP_IMPL_IS_CLIPBOARD_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_CLIPBOARD_PROXY))
#define XDP_IMPL_IS_CLIPBOARD_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_CLIPBOARD_PROXY))

typedef struct _XdpImplClipboardProxy XdpImplClipboardProxy;
typedef struct _XdpImplClipboardProxyClass XdpImplClipboardProxyClass;
typedef struct _XdpImplClipboardProxyPrivate XdpImplClipboardProxyPrivate;

struct _XdpImplClipboardProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplClipboardProxyPrivate *priv;
};

struct _XdpImplClipboardProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_clipboard_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_clipboard_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplClipboard *xdp_impl_clipboard_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplClipboard *xdp_impl_clipboard_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplClipboard *xdp_impl_clipboard_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplClipboard *xdp_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_IMPL_TYPE_CLIPBOARD_SKELETON (xdp_impl_clipboard_skeleton_get_type ())
#define XDP_IMPL_CLIPBOARD_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_CLIPBOARD_SKELETON, XdpImplClipboardSkeleton))
#define XDP_IMPL_CLIPBOARD_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_CLIPBOARD_SKELETON, XdpImplClipboardSkeletonClass))
#define XDP_IMPL_CLIPBOARD_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_CLIPBOARD_SKELETON, XdpImplClipboardSkeletonClass))
#define XDP_IMPL_IS_CLIPBOARD_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_CLIPBOARD_SKELETON))
#define XDP_IMPL_IS_CLIPBOARD_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_CLIPBOARD_SKELETON))

typedef struct _XdpImplClipboardSkeleton XdpImplClipboardSkeleton;
typedef struct _XdpImplClipboardSkeletonClass XdpImplClipboardSkeletonClass;
typedef struct _XdpImplClipboardSkeletonPrivate XdpImplClipboardSkeletonPrivate;

struct _XdpImplClipboardSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplClipboardSkeletonPrivate *priv;
};

struct _XdpImplClipboardSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_clipboard_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplClipboard *xdp_impl_clipboard_skeleton_new (void);


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

#define XDP_IMPL_TYPE_DYNAMIC_LAUNCHER (xdp_impl_dynamic_launcher_get_type ())
#define XDP_IMPL_DYNAMIC_LAUNCHER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_DYNAMIC_LAUNCHER, XdpImplDynamicLauncher))
#define XDP_IMPL_IS_DYNAMIC_LAUNCHER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_DYNAMIC_LAUNCHER))
#define XDP_IMPL_DYNAMIC_LAUNCHER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_DYNAMIC_LAUNCHER, XdpImplDynamicLauncherIface))

struct _XdpImplDynamicLauncher;
typedef struct _XdpImplDynamicLauncher XdpImplDynamicLauncher;
typedef struct _XdpImplDynamicLauncherIface XdpImplDynamicLauncherIface;

struct _XdpImplDynamicLauncherIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_prepare_install) (
    XdpImplDynamicLauncher *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) (
    XdpImplDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_app_id,
    GVariant *arg_options);

  guint  (*get_supported_launcher_types) (XdpImplDynamicLauncher *object);

  guint  (*get_version) (XdpImplDynamicLauncher *object);

};

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

GType xdp_impl_dynamic_launcher_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_dynamic_launcher_interface_info (void);
guint xdp_impl_dynamic_launcher_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_dynamic_launcher_complete_request_install_token (
    XdpImplDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    guint response);



/* D-Bus method calls: */
void xdp_impl_dynamic_launcher_call_prepare_install (
    XdpImplDynamicLauncher *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_impl_dynamic_launcher_call_prepare_install_finish (
    XdpImplDynamicLauncher *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_dynamic_launcher_call_prepare_install_sync (
    XdpImplDynamicLauncher *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_impl_dynamic_launcher_call_request_install_token (
    XdpImplDynamicLauncher *proxy,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_impl_dynamic_launcher_call_request_install_token_finish (
    XdpImplDynamicLauncher *proxy,
    guint* out_response,
    GAsyncResult *res,
    GError **error);

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



/* D-Bus property accessors: */
guint xdp_impl_dynamic_launcher_get_supported_launcher_types (XdpImplDynamicLauncher *object);
void xdp_impl_dynamic_launcher_set_supported_launcher_types (XdpImplDynamicLauncher *object, guint value);

guint xdp_impl_dynamic_launcher_get_version (XdpImplDynamicLauncher *object);
void xdp_impl_dynamic_launcher_set_version (XdpImplDynamicLauncher *object, guint value);


/* ---- */

#define XDP_IMPL_TYPE_DYNAMIC_LAUNCHER_PROXY (xdp_impl_dynamic_launcher_proxy_get_type ())
#define XDP_IMPL_DYNAMIC_LAUNCHER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_DYNAMIC_LAUNCHER_PROXY, XdpImplDynamicLauncherProxy))
#define XDP_IMPL_DYNAMIC_LAUNCHER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_DYNAMIC_LAUNCHER_PROXY, XdpImplDynamicLauncherProxyClass))
#define XDP_IMPL_DYNAMIC_LAUNCHER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_DYNAMIC_LAUNCHER_PROXY, XdpImplDynamicLauncherProxyClass))
#define XDP_IMPL_IS_DYNAMIC_LAUNCHER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_DYNAMIC_LAUNCHER_PROXY))
#define XDP_IMPL_IS_DYNAMIC_LAUNCHER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_DYNAMIC_LAUNCHER_PROXY))

typedef struct _XdpImplDynamicLauncherProxy XdpImplDynamicLauncherProxy;
typedef struct _XdpImplDynamicLauncherProxyClass XdpImplDynamicLauncherProxyClass;
typedef struct _XdpImplDynamicLauncherProxyPrivate XdpImplDynamicLauncherProxyPrivate;

struct _XdpImplDynamicLauncherProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplDynamicLauncherProxyPrivate *priv;
};

struct _XdpImplDynamicLauncherProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_dynamic_launcher_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_dynamic_launcher_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplDynamicLauncher *xdp_impl_dynamic_launcher_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplDynamicLauncher *xdp_impl_dynamic_launcher_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplDynamicLauncher *xdp_impl_dynamic_launcher_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplDynamicLauncher *xdp_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_IMPL_TYPE_DYNAMIC_LAUNCHER_SKELETON (xdp_impl_dynamic_launcher_skeleton_get_type ())
#define XDP_IMPL_DYNAMIC_LAUNCHER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_DYNAMIC_LAUNCHER_SKELETON, XdpImplDynamicLauncherSkeleton))
#define XDP_IMPL_DYNAMIC_LAUNCHER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_DYNAMIC_LAUNCHER_SKELETON, XdpImplDynamicLauncherSkeletonClass))
#define XDP_IMPL_DYNAMIC_LAUNCHER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_DYNAMIC_LAUNCHER_SKELETON, XdpImplDynamicLauncherSkeletonClass))
#define XDP_IMPL_IS_DYNAMIC_LAUNCHER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_DYNAMIC_LAUNCHER_SKELETON))
#define XDP_IMPL_IS_DYNAMIC_LAUNCHER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_DYNAMIC_LAUNCHER_SKELETON))

typedef struct _XdpImplDynamicLauncherSkeleton XdpImplDynamicLauncherSkeleton;
typedef struct _XdpImplDynamicLauncherSkeletonClass XdpImplDynamicLauncherSkeletonClass;
typedef struct _XdpImplDynamicLauncherSkeletonPrivate XdpImplDynamicLauncherSkeletonPrivate;

struct _XdpImplDynamicLauncherSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplDynamicLauncherSkeletonPrivate *priv;
};

struct _XdpImplDynamicLauncherSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_dynamic_launcher_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplDynamicLauncher *xdp_impl_dynamic_launcher_skeleton_new (void);


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

#define XDP_IMPL_TYPE_FILE_CHOOSER (xdp_impl_file_chooser_get_type ())
#define XDP_IMPL_FILE_CHOOSER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_FILE_CHOOSER, XdpImplFileChooser))
#define XDP_IMPL_IS_FILE_CHOOSER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_FILE_CHOOSER))
#define XDP_IMPL_FILE_CHOOSER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_FILE_CHOOSER, XdpImplFileChooserIface))

struct _XdpImplFileChooser;
typedef struct _XdpImplFileChooser XdpImplFileChooser;
typedef struct _XdpImplFileChooserIface XdpImplFileChooserIface;

struct _XdpImplFileChooserIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_open_file) (
    XdpImplFileChooser *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) (
    XdpImplFileChooser *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) (
    XdpImplFileChooser *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 (XdpImplFileChooser, g_object_unref)
#endif

GType xdp_impl_file_chooser_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_file_chooser_interface_info (void);
guint xdp_impl_file_chooser_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_file_chooser_complete_save_file (
    XdpImplFileChooser *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_impl_file_chooser_complete_save_files (
    XdpImplFileChooser *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);



/* D-Bus method calls: */
void xdp_impl_file_chooser_call_open_file (
    XdpImplFileChooser *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_impl_file_chooser_call_open_file_finish (
    XdpImplFileChooser *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_file_chooser_call_open_file_sync (
    XdpImplFileChooser *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_impl_file_chooser_call_save_file (
    XdpImplFileChooser *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_impl_file_chooser_call_save_file_finish (
    XdpImplFileChooser *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_file_chooser_call_save_file_sync (
    XdpImplFileChooser *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_impl_file_chooser_call_save_files (
    XdpImplFileChooser *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_impl_file_chooser_call_save_files_finish (
    XdpImplFileChooser *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_file_chooser_call_save_files_sync (
    XdpImplFileChooser *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_IMPL_TYPE_FILE_CHOOSER_PROXY (xdp_impl_file_chooser_proxy_get_type ())
#define XDP_IMPL_FILE_CHOOSER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_FILE_CHOOSER_PROXY, XdpImplFileChooserProxy))
#define XDP_IMPL_FILE_CHOOSER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_FILE_CHOOSER_PROXY, XdpImplFileChooserProxyClass))
#define XDP_IMPL_FILE_CHOOSER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_FILE_CHOOSER_PROXY, XdpImplFileChooserProxyClass))
#define XDP_IMPL_IS_FILE_CHOOSER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_FILE_CHOOSER_PROXY))
#define XDP_IMPL_IS_FILE_CHOOSER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_FILE_CHOOSER_PROXY))

typedef struct _XdpImplFileChooserProxy XdpImplFileChooserProxy;
typedef struct _XdpImplFileChooserProxyClass XdpImplFileChooserProxyClass;
typedef struct _XdpImplFileChooserProxyPrivate XdpImplFileChooserProxyPrivate;

struct _XdpImplFileChooserProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplFileChooserProxyPrivate *priv;
};

struct _XdpImplFileChooserProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_file_chooser_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_file_chooser_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplFileChooser *xdp_impl_file_chooser_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplFileChooser *xdp_impl_file_chooser_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplFileChooser *xdp_impl_file_chooser_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplFileChooser *xdp_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_IMPL_TYPE_FILE_CHOOSER_SKELETON (xdp_impl_file_chooser_skeleton_get_type ())
#define XDP_IMPL_FILE_CHOOSER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_FILE_CHOOSER_SKELETON, XdpImplFileChooserSkeleton))
#define XDP_IMPL_FILE_CHOOSER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_FILE_CHOOSER_SKELETON, XdpImplFileChooserSkeletonClass))
#define XDP_IMPL_FILE_CHOOSER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_FILE_CHOOSER_SKELETON, XdpImplFileChooserSkeletonClass))
#define XDP_IMPL_IS_FILE_CHOOSER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_FILE_CHOOSER_SKELETON))
#define XDP_IMPL_IS_FILE_CHOOSER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_FILE_CHOOSER_SKELETON))

typedef struct _XdpImplFileChooserSkeleton XdpImplFileChooserSkeleton;
typedef struct _XdpImplFileChooserSkeletonClass XdpImplFileChooserSkeletonClass;
typedef struct _XdpImplFileChooserSkeletonPrivate XdpImplFileChooserSkeletonPrivate;

struct _XdpImplFileChooserSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplFileChooserSkeletonPrivate *priv;
};

struct _XdpImplFileChooserSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_file_chooser_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplFileChooser *xdp_impl_file_chooser_skeleton_new (void);


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

#define XDP_IMPL_TYPE_GLOBAL_SHORTCUTS (xdp_impl_global_shortcuts_get_type ())
#define XDP_IMPL_GLOBAL_SHORTCUTS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_GLOBAL_SHORTCUTS, XdpImplGlobalShortcuts))
#define XDP_IMPL_IS_GLOBAL_SHORTCUTS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_GLOBAL_SHORTCUTS))
#define XDP_IMPL_GLOBAL_SHORTCUTS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_GLOBAL_SHORTCUTS, XdpImplGlobalShortcutsIface))

struct _XdpImplGlobalShortcuts;
typedef struct _XdpImplGlobalShortcuts XdpImplGlobalShortcuts;
typedef struct _XdpImplGlobalShortcutsIface XdpImplGlobalShortcutsIface;

struct _XdpImplGlobalShortcutsIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_bind_shortcuts) (
    XdpImplGlobalShortcuts *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_create_session) (
    XdpImplGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

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

  guint  (*get_version) (XdpImplGlobalShortcuts *object);

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

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

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

};

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

GType xdp_impl_global_shortcuts_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_global_shortcuts_interface_info (void);
guint xdp_impl_global_shortcuts_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_global_shortcuts_complete_bind_shortcuts (
    XdpImplGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_impl_global_shortcuts_complete_list_shortcuts (
    XdpImplGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);



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

void xdp_impl_global_shortcuts_emit_deactivated (
    XdpImplGlobalShortcuts *object,
    const gchar *arg_session_handle,
    const gchar *arg_shortcut_id,
    guint64 arg_timestamp,
    GVariant *arg_options);

void xdp_impl_global_shortcuts_emit_shortcuts_changed (
    XdpImplGlobalShortcuts *object,
    const gchar *arg_session_handle,
    GVariant *arg_shortcuts);



/* D-Bus method calls: */
void xdp_impl_global_shortcuts_call_create_session (
    XdpImplGlobalShortcuts *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_impl_global_shortcuts_call_create_session_finish (
    XdpImplGlobalShortcuts *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_global_shortcuts_call_create_session_sync (
    XdpImplGlobalShortcuts *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_impl_global_shortcuts_call_bind_shortcuts (
    XdpImplGlobalShortcuts *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_impl_global_shortcuts_call_bind_shortcuts_finish (
    XdpImplGlobalShortcuts *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_global_shortcuts_call_bind_shortcuts_sync (
    XdpImplGlobalShortcuts *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_impl_global_shortcuts_call_list_shortcuts (
    XdpImplGlobalShortcuts *proxy,
    const gchar *arg_handle,
    const gchar *arg_session_handle,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_impl_global_shortcuts_call_list_shortcuts_finish (
    XdpImplGlobalShortcuts *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

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



/* D-Bus property accessors: */
guint xdp_impl_global_shortcuts_get_version (XdpImplGlobalShortcuts *object);
void xdp_impl_global_shortcuts_set_version (XdpImplGlobalShortcuts *object, guint value);


/* ---- */

#define XDP_IMPL_TYPE_GLOBAL_SHORTCUTS_PROXY (xdp_impl_global_shortcuts_proxy_get_type ())
#define XDP_IMPL_GLOBAL_SHORTCUTS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_GLOBAL_SHORTCUTS_PROXY, XdpImplGlobalShortcutsProxy))
#define XDP_IMPL_GLOBAL_SHORTCUTS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_GLOBAL_SHORTCUTS_PROXY, XdpImplGlobalShortcutsProxyClass))
#define XDP_IMPL_GLOBAL_SHORTCUTS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_GLOBAL_SHORTCUTS_PROXY, XdpImplGlobalShortcutsProxyClass))
#define XDP_IMPL_IS_GLOBAL_SHORTCUTS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_GLOBAL_SHORTCUTS_PROXY))
#define XDP_IMPL_IS_GLOBAL_SHORTCUTS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_GLOBAL_SHORTCUTS_PROXY))

typedef struct _XdpImplGlobalShortcutsProxy XdpImplGlobalShortcutsProxy;
typedef struct _XdpImplGlobalShortcutsProxyClass XdpImplGlobalShortcutsProxyClass;
typedef struct _XdpImplGlobalShortcutsProxyPrivate XdpImplGlobalShortcutsProxyPrivate;

struct _XdpImplGlobalShortcutsProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplGlobalShortcutsProxyPrivate *priv;
};

struct _XdpImplGlobalShortcutsProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_global_shortcuts_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_global_shortcuts_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplGlobalShortcuts *xdp_impl_global_shortcuts_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplGlobalShortcuts *xdp_impl_global_shortcuts_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplGlobalShortcuts *xdp_impl_global_shortcuts_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplGlobalShortcuts *xdp_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_IMPL_TYPE_GLOBAL_SHORTCUTS_SKELETON (xdp_impl_global_shortcuts_skeleton_get_type ())
#define XDP_IMPL_GLOBAL_SHORTCUTS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_GLOBAL_SHORTCUTS_SKELETON, XdpImplGlobalShortcutsSkeleton))
#define XDP_IMPL_GLOBAL_SHORTCUTS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_GLOBAL_SHORTCUTS_SKELETON, XdpImplGlobalShortcutsSkeletonClass))
#define XDP_IMPL_GLOBAL_SHORTCUTS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_GLOBAL_SHORTCUTS_SKELETON, XdpImplGlobalShortcutsSkeletonClass))
#define XDP_IMPL_IS_GLOBAL_SHORTCUTS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_GLOBAL_SHORTCUTS_SKELETON))
#define XDP_IMPL_IS_GLOBAL_SHORTCUTS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_GLOBAL_SHORTCUTS_SKELETON))

typedef struct _XdpImplGlobalShortcutsSkeleton XdpImplGlobalShortcutsSkeleton;
typedef struct _XdpImplGlobalShortcutsSkeletonClass XdpImplGlobalShortcutsSkeletonClass;
typedef struct _XdpImplGlobalShortcutsSkeletonPrivate XdpImplGlobalShortcutsSkeletonPrivate;

struct _XdpImplGlobalShortcutsSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplGlobalShortcutsSkeletonPrivate *priv;
};

struct _XdpImplGlobalShortcutsSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_global_shortcuts_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplGlobalShortcuts *xdp_impl_global_shortcuts_skeleton_new (void);


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

#define XDP_IMPL_TYPE_INPUT_CAPTURE (xdp_impl_input_capture_get_type ())
#define XDP_IMPL_INPUT_CAPTURE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_INPUT_CAPTURE, XdpImplInputCapture))
#define XDP_IMPL_IS_INPUT_CAPTURE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_INPUT_CAPTURE))
#define XDP_IMPL_INPUT_CAPTURE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_INPUT_CAPTURE, XdpImplInputCaptureIface))

struct _XdpImplInputCapture;
typedef struct _XdpImplInputCapture XdpImplInputCapture;
typedef struct _XdpImplInputCaptureIface XdpImplInputCaptureIface;

struct _XdpImplInputCaptureIface
{
  GTypeInterface parent_iface;



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

  gboolean (*handle_create_session) (
    XdpImplInputCapture *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_disable) (
    XdpImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options);

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

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

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

  gboolean (*handle_set_pointer_barriers) (
    XdpImplInputCapture *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);

  guint  (*get_supported_capabilities) (XdpImplInputCapture *object);

  guint  (*get_version) (XdpImplInputCapture *object);

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

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

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

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

};

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

GType xdp_impl_input_capture_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_input_capture_interface_info (void);
guint xdp_impl_input_capture_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_input_capture_complete_get_zones (
    XdpImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_impl_input_capture_complete_set_pointer_barriers (
    XdpImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_impl_input_capture_complete_enable (
    XdpImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_impl_input_capture_complete_disable (
    XdpImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_impl_input_capture_complete_release (
    XdpImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_impl_input_capture_complete_connect_to_eis (
    XdpImplInputCapture *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);



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

void xdp_impl_input_capture_emit_activated (
    XdpImplInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);

void xdp_impl_input_capture_emit_deactivated (
    XdpImplInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);

void xdp_impl_input_capture_emit_zones_changed (
    XdpImplInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);



/* D-Bus method calls: */
void xdp_impl_input_capture_call_create_session (
    XdpImplInputCapture *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_impl_input_capture_call_create_session_finish (
    XdpImplInputCapture *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_input_capture_call_create_session_sync (
    XdpImplInputCapture *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_impl_input_capture_call_get_zones (
    XdpImplInputCapture *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_impl_input_capture_call_get_zones_finish (
    XdpImplInputCapture *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_input_capture_call_get_zones_sync (
    XdpImplInputCapture *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_impl_input_capture_call_set_pointer_barriers (
    XdpImplInputCapture *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_impl_input_capture_call_set_pointer_barriers_finish (
    XdpImplInputCapture *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_input_capture_call_set_pointer_barriers_sync (
    XdpImplInputCapture *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_impl_input_capture_call_enable (
    XdpImplInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_impl_input_capture_call_enable_finish (
    XdpImplInputCapture *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_input_capture_call_enable_sync (
    XdpImplInputCapture *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_impl_input_capture_call_disable (
    XdpImplInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_impl_input_capture_call_disable_finish (
    XdpImplInputCapture *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_input_capture_call_disable_sync (
    XdpImplInputCapture *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_impl_input_capture_call_release (
    XdpImplInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_app_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_impl_input_capture_call_release_finish (
    XdpImplInputCapture *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_input_capture_call_release_sync (
    XdpImplInputCapture *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_impl_input_capture_call_connect_to_eis (
    XdpImplInputCapture *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_impl_input_capture_call_connect_to_eis_finish (
    XdpImplInputCapture *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_input_capture_call_connect_to_eis_sync (
    XdpImplInputCapture *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_impl_input_capture_get_supported_capabilities (XdpImplInputCapture *object);
void xdp_impl_input_capture_set_supported_capabilities (XdpImplInputCapture *object, guint value);

guint xdp_impl_input_capture_get_version (XdpImplInputCapture *object);
void xdp_impl_input_capture_set_version (XdpImplInputCapture *object, guint value);


/* ---- */

#define XDP_IMPL_TYPE_INPUT_CAPTURE_PROXY (xdp_impl_input_capture_proxy_get_type ())
#define XDP_IMPL_INPUT_CAPTURE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_INPUT_CAPTURE_PROXY, XdpImplInputCaptureProxy))
#define XDP_IMPL_INPUT_CAPTURE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_INPUT_CAPTURE_PROXY, XdpImplInputCaptureProxyClass))
#define XDP_IMPL_INPUT_CAPTURE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_INPUT_CAPTURE_PROXY, XdpImplInputCaptureProxyClass))
#define XDP_IMPL_IS_INPUT_CAPTURE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_INPUT_CAPTURE_PROXY))
#define XDP_IMPL_IS_INPUT_CAPTURE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_INPUT_CAPTURE_PROXY))

typedef struct _XdpImplInputCaptureProxy XdpImplInputCaptureProxy;
typedef struct _XdpImplInputCaptureProxyClass XdpImplInputCaptureProxyClass;
typedef struct _XdpImplInputCaptureProxyPrivate XdpImplInputCaptureProxyPrivate;

struct _XdpImplInputCaptureProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplInputCaptureProxyPrivate *priv;
};

struct _XdpImplInputCaptureProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_input_capture_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_input_capture_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplInputCapture *xdp_impl_input_capture_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplInputCapture *xdp_impl_input_capture_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplInputCapture *xdp_impl_input_capture_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplInputCapture *xdp_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_IMPL_TYPE_INPUT_CAPTURE_SKELETON (xdp_impl_input_capture_skeleton_get_type ())
#define XDP_IMPL_INPUT_CAPTURE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_INPUT_CAPTURE_SKELETON, XdpImplInputCaptureSkeleton))
#define XDP_IMPL_INPUT_CAPTURE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_INPUT_CAPTURE_SKELETON, XdpImplInputCaptureSkeletonClass))
#define XDP_IMPL_INPUT_CAPTURE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_INPUT_CAPTURE_SKELETON, XdpImplInputCaptureSkeletonClass))
#define XDP_IMPL_IS_INPUT_CAPTURE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_INPUT_CAPTURE_SKELETON))
#define XDP_IMPL_IS_INPUT_CAPTURE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_INPUT_CAPTURE_SKELETON))

typedef struct _XdpImplInputCaptureSkeleton XdpImplInputCaptureSkeleton;
typedef struct _XdpImplInputCaptureSkeletonClass XdpImplInputCaptureSkeletonClass;
typedef struct _XdpImplInputCaptureSkeletonPrivate XdpImplInputCaptureSkeletonPrivate;

struct _XdpImplInputCaptureSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplInputCaptureSkeletonPrivate *priv;
};

struct _XdpImplInputCaptureSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_input_capture_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplInputCapture *xdp_impl_input_capture_skeleton_new (void);


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

#define XDP_IMPL_TYPE_LOCKDOWN (xdp_impl_lockdown_get_type ())
#define XDP_IMPL_LOCKDOWN(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_LOCKDOWN, XdpImplLockdown))
#define XDP_IMPL_IS_LOCKDOWN(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_LOCKDOWN))
#define XDP_IMPL_LOCKDOWN_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_LOCKDOWN, XdpImplLockdownIface))

struct _XdpImplLockdown;
typedef struct _XdpImplLockdown XdpImplLockdown;
typedef struct _XdpImplLockdownIface XdpImplLockdownIface;

struct _XdpImplLockdownIface
{
  GTypeInterface parent_iface;

  gboolean  (*get_disable_application_handlers) (XdpImplLockdown *object);

  gboolean  (*get_disable_camera) (XdpImplLockdown *object);

  gboolean  (*get_disable_location) (XdpImplLockdown *object);

  gboolean  (*get_disable_microphone) (XdpImplLockdown *object);

  gboolean  (*get_disable_printing) (XdpImplLockdown *object);

  gboolean  (*get_disable_save_to_disk) (XdpImplLockdown *object);

  gboolean  (*get_disable_sound_output) (XdpImplLockdown *object);

};

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

GType xdp_impl_lockdown_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_lockdown_interface_info (void);
guint xdp_impl_lockdown_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus property accessors: */
gboolean xdp_impl_lockdown_get_disable_printing (XdpImplLockdown *object);
void xdp_impl_lockdown_set_disable_printing (XdpImplLockdown *object, gboolean value);

gboolean xdp_impl_lockdown_get_disable_save_to_disk (XdpImplLockdown *object);
void xdp_impl_lockdown_set_disable_save_to_disk (XdpImplLockdown *object, gboolean value);

gboolean xdp_impl_lockdown_get_disable_application_handlers (XdpImplLockdown *object);
void xdp_impl_lockdown_set_disable_application_handlers (XdpImplLockdown *object, gboolean value);

gboolean xdp_impl_lockdown_get_disable_location (XdpImplLockdown *object);
void xdp_impl_lockdown_set_disable_location (XdpImplLockdown *object, gboolean value);

gboolean xdp_impl_lockdown_get_disable_camera (XdpImplLockdown *object);
void xdp_impl_lockdown_set_disable_camera (XdpImplLockdown *object, gboolean value);

gboolean xdp_impl_lockdown_get_disable_microphone (XdpImplLockdown *object);
void xdp_impl_lockdown_set_disable_microphone (XdpImplLockdown *object, gboolean value);

gboolean xdp_impl_lockdown_get_disable_sound_output (XdpImplLockdown *object);
void xdp_impl_lockdown_set_disable_sound_output (XdpImplLockdown *object, gboolean value);


/* ---- */

#define XDP_IMPL_TYPE_LOCKDOWN_PROXY (xdp_impl_lockdown_proxy_get_type ())
#define XDP_IMPL_LOCKDOWN_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_LOCKDOWN_PROXY, XdpImplLockdownProxy))
#define XDP_IMPL_LOCKDOWN_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_LOCKDOWN_PROXY, XdpImplLockdownProxyClass))
#define XDP_IMPL_LOCKDOWN_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_LOCKDOWN_PROXY, XdpImplLockdownProxyClass))
#define XDP_IMPL_IS_LOCKDOWN_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_LOCKDOWN_PROXY))
#define XDP_IMPL_IS_LOCKDOWN_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_LOCKDOWN_PROXY))

typedef struct _XdpImplLockdownProxy XdpImplLockdownProxy;
typedef struct _XdpImplLockdownProxyClass XdpImplLockdownProxyClass;
typedef struct _XdpImplLockdownProxyPrivate XdpImplLockdownProxyPrivate;

struct _XdpImplLockdownProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplLockdownProxyPrivate *priv;
};

struct _XdpImplLockdownProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_lockdown_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_lockdown_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplLockdown *xdp_impl_lockdown_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplLockdown *xdp_impl_lockdown_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplLockdown *xdp_impl_lockdown_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplLockdown *xdp_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_IMPL_TYPE_LOCKDOWN_SKELETON (xdp_impl_lockdown_skeleton_get_type ())
#define XDP_IMPL_LOCKDOWN_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_LOCKDOWN_SKELETON, XdpImplLockdownSkeleton))
#define XDP_IMPL_LOCKDOWN_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_LOCKDOWN_SKELETON, XdpImplLockdownSkeletonClass))
#define XDP_IMPL_LOCKDOWN_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_LOCKDOWN_SKELETON, XdpImplLockdownSkeletonClass))
#define XDP_IMPL_IS_LOCKDOWN_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_LOCKDOWN_SKELETON))
#define XDP_IMPL_IS_LOCKDOWN_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_LOCKDOWN_SKELETON))

typedef struct _XdpImplLockdownSkeleton XdpImplLockdownSkeleton;
typedef struct _XdpImplLockdownSkeletonClass XdpImplLockdownSkeletonClass;
typedef struct _XdpImplLockdownSkeletonPrivate XdpImplLockdownSkeletonPrivate;

struct _XdpImplLockdownSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplLockdownSkeletonPrivate *priv;
};

struct _XdpImplLockdownSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_lockdown_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplLockdown *xdp_impl_lockdown_skeleton_new (void);


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

#define XDP_IMPL_TYPE_NOTIFICATION (xdp_impl_notification_get_type ())
#define XDP_IMPL_NOTIFICATION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_NOTIFICATION, XdpImplNotification))
#define XDP_IMPL_IS_NOTIFICATION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_NOTIFICATION))
#define XDP_IMPL_NOTIFICATION_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_NOTIFICATION, XdpImplNotificationIface))

struct _XdpImplNotification;
typedef struct _XdpImplNotification XdpImplNotification;
typedef struct _XdpImplNotificationIface XdpImplNotificationIface;

struct _XdpImplNotificationIface
{
  GTypeInterface parent_iface;



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

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

  GVariant * (*get_supported_options) (XdpImplNotification *object);

  guint  (*get_version) (XdpImplNotification *object);

  void (*action_invoked) (
    XdpImplNotification *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 (XdpImplNotification, g_object_unref)
#endif

GType xdp_impl_notification_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_notification_interface_info (void);
guint xdp_impl_notification_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_notification_complete_remove_notification (
    XdpImplNotification *object,
    GDBusMethodInvocation *invocation);



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



/* D-Bus method calls: */
void xdp_impl_notification_call_add_notification (
    XdpImplNotification *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_impl_notification_call_add_notification_finish (
    XdpImplNotification *proxy,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_notification_call_add_notification_sync (
    XdpImplNotification *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_impl_notification_call_remove_notification (
    XdpImplNotification *proxy,
    const gchar *arg_app_id,
    const gchar *arg_id,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_impl_notification_call_remove_notification_finish (
    XdpImplNotification *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_notification_call_remove_notification_sync (
    XdpImplNotification *proxy,
    const gchar *arg_app_id,
    const gchar *arg_id,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
GVariant *xdp_impl_notification_get_supported_options (XdpImplNotification *object);
GVariant *xdp_impl_notification_dup_supported_options (XdpImplNotification *object);
void xdp_impl_notification_set_supported_options (XdpImplNotification *object, GVariant *value);

guint xdp_impl_notification_get_version (XdpImplNotification *object);
void xdp_impl_notification_set_version (XdpImplNotification *object, guint value);


/* ---- */

#define XDP_IMPL_TYPE_NOTIFICATION_PROXY (xdp_impl_notification_proxy_get_type ())
#define XDP_IMPL_NOTIFICATION_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_NOTIFICATION_PROXY, XdpImplNotificationProxy))
#define XDP_IMPL_NOTIFICATION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_NOTIFICATION_PROXY, XdpImplNotificationProxyClass))
#define XDP_IMPL_NOTIFICATION_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_NOTIFICATION_PROXY, XdpImplNotificationProxyClass))
#define XDP_IMPL_IS_NOTIFICATION_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_NOTIFICATION_PROXY))
#define XDP_IMPL_IS_NOTIFICATION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_NOTIFICATION_PROXY))

typedef struct _XdpImplNotificationProxy XdpImplNotificationProxy;
typedef struct _XdpImplNotificationProxyClass XdpImplNotificationProxyClass;
typedef struct _XdpImplNotificationProxyPrivate XdpImplNotificationProxyPrivate;

struct _XdpImplNotificationProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplNotificationProxyPrivate *priv;
};

struct _XdpImplNotificationProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_notification_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_notification_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplNotification *xdp_impl_notification_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplNotification *xdp_impl_notification_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplNotification *xdp_impl_notification_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplNotification *xdp_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_IMPL_TYPE_NOTIFICATION_SKELETON (xdp_impl_notification_skeleton_get_type ())
#define XDP_IMPL_NOTIFICATION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_NOTIFICATION_SKELETON, XdpImplNotificationSkeleton))
#define XDP_IMPL_NOTIFICATION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_NOTIFICATION_SKELETON, XdpImplNotificationSkeletonClass))
#define XDP_IMPL_NOTIFICATION_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_NOTIFICATION_SKELETON, XdpImplNotificationSkeletonClass))
#define XDP_IMPL_IS_NOTIFICATION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_NOTIFICATION_SKELETON))
#define XDP_IMPL_IS_NOTIFICATION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_NOTIFICATION_SKELETON))

typedef struct _XdpImplNotificationSkeleton XdpImplNotificationSkeleton;
typedef struct _XdpImplNotificationSkeletonClass XdpImplNotificationSkeletonClass;
typedef struct _XdpImplNotificationSkeletonPrivate XdpImplNotificationSkeletonPrivate;

struct _XdpImplNotificationSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplNotificationSkeletonPrivate *priv;
};

struct _XdpImplNotificationSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_notification_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplNotification *xdp_impl_notification_skeleton_new (void);


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

#define XDP_IMPL_TYPE_PRINT (xdp_impl_print_get_type ())
#define XDP_IMPL_PRINT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_PRINT, XdpImplPrint))
#define XDP_IMPL_IS_PRINT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_PRINT))
#define XDP_IMPL_PRINT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_PRINT, XdpImplPrintIface))

struct _XdpImplPrint;
typedef struct _XdpImplPrint XdpImplPrint;
typedef struct _XdpImplPrintIface XdpImplPrintIface;

struct _XdpImplPrintIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_prepare_print) (
    XdpImplPrint *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) (
    XdpImplPrint *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 (XdpImplPrint, g_object_unref)
#endif

GType xdp_impl_print_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_print_interface_info (void);
guint xdp_impl_print_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_print_complete_print (
    XdpImplPrint *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    guint response,
    GVariant *results);



/* D-Bus method calls: */
void xdp_impl_print_call_prepare_print (
    XdpImplPrint *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_impl_print_call_prepare_print_finish (
    XdpImplPrint *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_print_call_prepare_print_sync (
    XdpImplPrint *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_impl_print_call_print (
    XdpImplPrint *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_impl_print_call_print_finish (
    XdpImplPrint *proxy,
    guint* out_response,
    GVariant ** out_results,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_print_call_print_sync (
    XdpImplPrint *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_IMPL_TYPE_PRINT_PROXY (xdp_impl_print_proxy_get_type ())
#define XDP_IMPL_PRINT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_PRINT_PROXY, XdpImplPrintProxy))
#define XDP_IMPL_PRINT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_PRINT_PROXY, XdpImplPrintProxyClass))
#define XDP_IMPL_PRINT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_PRINT_PROXY, XdpImplPrintProxyClass))
#define XDP_IMPL_IS_PRINT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_PRINT_PROXY))
#define XDP_IMPL_IS_PRINT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_PRINT_PROXY))

typedef struct _XdpImplPrintProxy XdpImplPrintProxy;
typedef struct _XdpImplPrintProxyClass XdpImplPrintProxyClass;
typedef struct _XdpImplPrintProxyPrivate XdpImplPrintProxyPrivate;

struct _XdpImplPrintProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplPrintProxyPrivate *priv;
};

struct _XdpImplPrintProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_print_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_print_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplPrint *xdp_impl_print_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplPrint *xdp_impl_print_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplPrint *xdp_impl_print_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplPrint *xdp_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_IMPL_TYPE_PRINT_SKELETON (xdp_impl_print_skeleton_get_type ())
#define XDP_IMPL_PRINT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_PRINT_SKELETON, XdpImplPrintSkeleton))
#define XDP_IMPL_PRINT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_PRINT_SKELETON, XdpImplPrintSkeletonClass))
#define XDP_IMPL_PRINT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_PRINT_SKELETON, XdpImplPrintSkeletonClass))
#define XDP_IMPL_IS_PRINT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_PRINT_SKELETON))
#define XDP_IMPL_IS_PRINT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_PRINT_SKELETON))

typedef struct _XdpImplPrintSkeleton XdpImplPrintSkeleton;
typedef struct _XdpImplPrintSkeletonClass XdpImplPrintSkeletonClass;
typedef struct _XdpImplPrintSkeletonPrivate XdpImplPrintSkeletonPrivate;

struct _XdpImplPrintSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplPrintSkeletonPrivate *priv;
};

struct _XdpImplPrintSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_print_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplPrint *xdp_impl_print_skeleton_new (void);


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

#define XDP_IMPL_TYPE_REMOTE_DESKTOP (xdp_impl_remote_desktop_get_type ())
#define XDP_IMPL_REMOTE_DESKTOP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_REMOTE_DESKTOP, XdpImplRemoteDesktop))
#define XDP_IMPL_IS_REMOTE_DESKTOP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_REMOTE_DESKTOP))
#define XDP_IMPL_REMOTE_DESKTOP_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_REMOTE_DESKTOP, XdpImplRemoteDesktopIface))

struct _XdpImplRemoteDesktop;
typedef struct _XdpImplRemoteDesktop XdpImplRemoteDesktop;
typedef struct _XdpImplRemoteDesktopIface XdpImplRemoteDesktopIface;

struct _XdpImplRemoteDesktopIface
{
  GTypeInterface parent_iface;


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

  gboolean (*handle_create_session) (
    XdpImplRemoteDesktop *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) (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gint arg_keycode,
    guint arg_state);

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

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

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

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

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

  gboolean (*handle_notify_pointer_motion_absolute) (
    XdpImplRemoteDesktop *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) (
    XdpImplRemoteDesktop *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) (
    XdpImplRemoteDesktop *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) (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_slot);

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

  gboolean (*handle_start) (
    XdpImplRemoteDesktop *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) (XdpImplRemoteDesktop *object);

  guint  (*get_version) (XdpImplRemoteDesktop *object);

};

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

GType xdp_impl_remote_desktop_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_remote_desktop_interface_info (void);
guint xdp_impl_remote_desktop_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_remote_desktop_complete_select_devices (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_impl_remote_desktop_complete_start (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_impl_remote_desktop_complete_notify_pointer_motion (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_impl_remote_desktop_complete_notify_pointer_motion_absolute (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_impl_remote_desktop_complete_notify_pointer_button (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_impl_remote_desktop_complete_notify_pointer_axis (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_impl_remote_desktop_complete_notify_pointer_axis_discrete (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_impl_remote_desktop_complete_notify_keyboard_keycode (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_impl_remote_desktop_complete_notify_keyboard_keysym (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_impl_remote_desktop_complete_notify_touch_down (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_impl_remote_desktop_complete_notify_touch_motion (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_impl_remote_desktop_complete_notify_touch_up (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_impl_remote_desktop_complete_connect_to_eis (
    XdpImplRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);



/* D-Bus method calls: */
void xdp_impl_remote_desktop_call_create_session (
    XdpImplRemoteDesktop *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_impl_remote_desktop_call_create_session_finish (
    XdpImplRemoteDesktop *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_remote_desktop_call_create_session_sync (
    XdpImplRemoteDesktop *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_impl_remote_desktop_call_select_devices (
    XdpImplRemoteDesktop *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_impl_remote_desktop_call_select_devices_finish (
    XdpImplRemoteDesktop *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_remote_desktop_call_select_devices_sync (
    XdpImplRemoteDesktop *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_impl_remote_desktop_call_start (
    XdpImplRemoteDesktop *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_impl_remote_desktop_call_start_finish (
    XdpImplRemoteDesktop *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_remote_desktop_call_start_sync (
    XdpImplRemoteDesktop *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_impl_remote_desktop_call_notify_pointer_motion (
    XdpImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gdouble arg_dx,
    gdouble arg_dy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_impl_remote_desktop_call_notify_pointer_motion_finish (
    XdpImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

void xdp_impl_remote_desktop_call_notify_pointer_motion_absolute (
    XdpImplRemoteDesktop *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_impl_remote_desktop_call_notify_pointer_motion_absolute_finish (
    XdpImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_impl_remote_desktop_call_notify_pointer_button_finish (
    XdpImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_impl_remote_desktop_call_notify_pointer_axis_finish (
    XdpImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_impl_remote_desktop_call_notify_pointer_axis_discrete_finish (
    XdpImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_impl_remote_desktop_call_notify_keyboard_keycode_finish (
    XdpImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_impl_remote_desktop_call_notify_keyboard_keysym_finish (
    XdpImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

void xdp_impl_remote_desktop_call_notify_touch_down (
    XdpImplRemoteDesktop *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_impl_remote_desktop_call_notify_touch_down_finish (
    XdpImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_remote_desktop_call_notify_touch_down_sync (
    XdpImplRemoteDesktop *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_impl_remote_desktop_call_notify_touch_motion (
    XdpImplRemoteDesktop *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_impl_remote_desktop_call_notify_touch_motion_finish (
    XdpImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_remote_desktop_call_notify_touch_motion_sync (
    XdpImplRemoteDesktop *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_impl_remote_desktop_call_notify_touch_up (
    XdpImplRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    guint arg_slot,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_impl_remote_desktop_call_notify_touch_up_finish (
    XdpImplRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

void xdp_impl_remote_desktop_call_connect_to_eis (
    XdpImplRemoteDesktop *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_impl_remote_desktop_call_connect_to_eis_finish (
    XdpImplRemoteDesktop *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_remote_desktop_call_connect_to_eis_sync (
    XdpImplRemoteDesktop *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_impl_remote_desktop_get_available_device_types (XdpImplRemoteDesktop *object);
void xdp_impl_remote_desktop_set_available_device_types (XdpImplRemoteDesktop *object, guint value);

guint xdp_impl_remote_desktop_get_version (XdpImplRemoteDesktop *object);
void xdp_impl_remote_desktop_set_version (XdpImplRemoteDesktop *object, guint value);


/* ---- */

#define XDP_IMPL_TYPE_REMOTE_DESKTOP_PROXY (xdp_impl_remote_desktop_proxy_get_type ())
#define XDP_IMPL_REMOTE_DESKTOP_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_REMOTE_DESKTOP_PROXY, XdpImplRemoteDesktopProxy))
#define XDP_IMPL_REMOTE_DESKTOP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_REMOTE_DESKTOP_PROXY, XdpImplRemoteDesktopProxyClass))
#define XDP_IMPL_REMOTE_DESKTOP_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_REMOTE_DESKTOP_PROXY, XdpImplRemoteDesktopProxyClass))
#define XDP_IMPL_IS_REMOTE_DESKTOP_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_REMOTE_DESKTOP_PROXY))
#define XDP_IMPL_IS_REMOTE_DESKTOP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_REMOTE_DESKTOP_PROXY))

typedef struct _XdpImplRemoteDesktopProxy XdpImplRemoteDesktopProxy;
typedef struct _XdpImplRemoteDesktopProxyClass XdpImplRemoteDesktopProxyClass;
typedef struct _XdpImplRemoteDesktopProxyPrivate XdpImplRemoteDesktopProxyPrivate;

struct _XdpImplRemoteDesktopProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplRemoteDesktopProxyPrivate *priv;
};

struct _XdpImplRemoteDesktopProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_remote_desktop_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_remote_desktop_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplRemoteDesktop *xdp_impl_remote_desktop_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplRemoteDesktop *xdp_impl_remote_desktop_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplRemoteDesktop *xdp_impl_remote_desktop_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplRemoteDesktop *xdp_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_IMPL_TYPE_REMOTE_DESKTOP_SKELETON (xdp_impl_remote_desktop_skeleton_get_type ())
#define XDP_IMPL_REMOTE_DESKTOP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_REMOTE_DESKTOP_SKELETON, XdpImplRemoteDesktopSkeleton))
#define XDP_IMPL_REMOTE_DESKTOP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_REMOTE_DESKTOP_SKELETON, XdpImplRemoteDesktopSkeletonClass))
#define XDP_IMPL_REMOTE_DESKTOP_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_REMOTE_DESKTOP_SKELETON, XdpImplRemoteDesktopSkeletonClass))
#define XDP_IMPL_IS_REMOTE_DESKTOP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_REMOTE_DESKTOP_SKELETON))
#define XDP_IMPL_IS_REMOTE_DESKTOP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_REMOTE_DESKTOP_SKELETON))

typedef struct _XdpImplRemoteDesktopSkeleton XdpImplRemoteDesktopSkeleton;
typedef struct _XdpImplRemoteDesktopSkeletonClass XdpImplRemoteDesktopSkeletonClass;
typedef struct _XdpImplRemoteDesktopSkeletonPrivate XdpImplRemoteDesktopSkeletonPrivate;

struct _XdpImplRemoteDesktopSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplRemoteDesktopSkeletonPrivate *priv;
};

struct _XdpImplRemoteDesktopSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_remote_desktop_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplRemoteDesktop *xdp_impl_remote_desktop_skeleton_new (void);


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

#define XDP_IMPL_TYPE_REQUEST (xdp_impl_request_get_type ())
#define XDP_IMPL_REQUEST(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_REQUEST, XdpImplRequest))
#define XDP_IMPL_IS_REQUEST(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_REQUEST))
#define XDP_IMPL_REQUEST_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_REQUEST, XdpImplRequestIface))

struct _XdpImplRequest;
typedef struct _XdpImplRequest XdpImplRequest;
typedef struct _XdpImplRequestIface XdpImplRequestIface;

struct _XdpImplRequestIface
{
  GTypeInterface parent_iface;

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

};

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

GType xdp_impl_request_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_request_interface_info (void);
guint xdp_impl_request_override_properties (GObjectClass *klass, guint property_id_begin);


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



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

gboolean xdp_impl_request_call_close_finish (
    XdpImplRequest *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_request_call_close_sync (
    XdpImplRequest *proxy,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_IMPL_TYPE_REQUEST_PROXY (xdp_impl_request_proxy_get_type ())
#define XDP_IMPL_REQUEST_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_REQUEST_PROXY, XdpImplRequestProxy))
#define XDP_IMPL_REQUEST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_REQUEST_PROXY, XdpImplRequestProxyClass))
#define XDP_IMPL_REQUEST_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_REQUEST_PROXY, XdpImplRequestProxyClass))
#define XDP_IMPL_IS_REQUEST_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_REQUEST_PROXY))
#define XDP_IMPL_IS_REQUEST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_REQUEST_PROXY))

typedef struct _XdpImplRequestProxy XdpImplRequestProxy;
typedef struct _XdpImplRequestProxyClass XdpImplRequestProxyClass;
typedef struct _XdpImplRequestProxyPrivate XdpImplRequestProxyPrivate;

struct _XdpImplRequestProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplRequestProxyPrivate *priv;
};

struct _XdpImplRequestProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_request_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_request_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplRequest *xdp_impl_request_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplRequest *xdp_impl_request_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplRequest *xdp_impl_request_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplRequest *xdp_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_IMPL_TYPE_REQUEST_SKELETON (xdp_impl_request_skeleton_get_type ())
#define XDP_IMPL_REQUEST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_REQUEST_SKELETON, XdpImplRequestSkeleton))
#define XDP_IMPL_REQUEST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_REQUEST_SKELETON, XdpImplRequestSkeletonClass))
#define XDP_IMPL_REQUEST_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_REQUEST_SKELETON, XdpImplRequestSkeletonClass))
#define XDP_IMPL_IS_REQUEST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_REQUEST_SKELETON))
#define XDP_IMPL_IS_REQUEST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_REQUEST_SKELETON))

typedef struct _XdpImplRequestSkeleton XdpImplRequestSkeleton;
typedef struct _XdpImplRequestSkeletonClass XdpImplRequestSkeletonClass;
typedef struct _XdpImplRequestSkeletonPrivate XdpImplRequestSkeletonPrivate;

struct _XdpImplRequestSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplRequestSkeletonPrivate *priv;
};

struct _XdpImplRequestSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_request_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplRequest *xdp_impl_request_skeleton_new (void);


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

#define XDP_IMPL_TYPE_SCREEN_CAST (xdp_impl_screen_cast_get_type ())
#define XDP_IMPL_SCREEN_CAST(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SCREEN_CAST, XdpImplScreenCast))
#define XDP_IMPL_IS_SCREEN_CAST(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SCREEN_CAST))
#define XDP_IMPL_SCREEN_CAST_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_SCREEN_CAST, XdpImplScreenCastIface))

struct _XdpImplScreenCast;
typedef struct _XdpImplScreenCast XdpImplScreenCast;
typedef struct _XdpImplScreenCastIface XdpImplScreenCastIface;

struct _XdpImplScreenCastIface
{
  GTypeInterface parent_iface;


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

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

  gboolean (*handle_start) (
    XdpImplScreenCast *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) (XdpImplScreenCast *object);

  guint  (*get_available_source_types) (XdpImplScreenCast *object);

  guint  (*get_version) (XdpImplScreenCast *object);

};

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

GType xdp_impl_screen_cast_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_screen_cast_interface_info (void);
guint xdp_impl_screen_cast_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_screen_cast_complete_select_sources (
    XdpImplScreenCast *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);

void xdp_impl_screen_cast_complete_start (
    XdpImplScreenCast *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);



/* D-Bus method calls: */
void xdp_impl_screen_cast_call_create_session (
    XdpImplScreenCast *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_impl_screen_cast_call_create_session_finish (
    XdpImplScreenCast *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_screen_cast_call_create_session_sync (
    XdpImplScreenCast *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_impl_screen_cast_call_select_sources (
    XdpImplScreenCast *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_impl_screen_cast_call_select_sources_finish (
    XdpImplScreenCast *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_screen_cast_call_select_sources_sync (
    XdpImplScreenCast *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_impl_screen_cast_call_start (
    XdpImplScreenCast *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_impl_screen_cast_call_start_finish (
    XdpImplScreenCast *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_screen_cast_call_start_sync (
    XdpImplScreenCast *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_impl_screen_cast_get_available_source_types (XdpImplScreenCast *object);
void xdp_impl_screen_cast_set_available_source_types (XdpImplScreenCast *object, guint value);

guint xdp_impl_screen_cast_get_available_cursor_modes (XdpImplScreenCast *object);
void xdp_impl_screen_cast_set_available_cursor_modes (XdpImplScreenCast *object, guint value);

guint xdp_impl_screen_cast_get_version (XdpImplScreenCast *object);
void xdp_impl_screen_cast_set_version (XdpImplScreenCast *object, guint value);


/* ---- */

#define XDP_IMPL_TYPE_SCREEN_CAST_PROXY (xdp_impl_screen_cast_proxy_get_type ())
#define XDP_IMPL_SCREEN_CAST_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SCREEN_CAST_PROXY, XdpImplScreenCastProxy))
#define XDP_IMPL_SCREEN_CAST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_SCREEN_CAST_PROXY, XdpImplScreenCastProxyClass))
#define XDP_IMPL_SCREEN_CAST_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_SCREEN_CAST_PROXY, XdpImplScreenCastProxyClass))
#define XDP_IMPL_IS_SCREEN_CAST_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SCREEN_CAST_PROXY))
#define XDP_IMPL_IS_SCREEN_CAST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_SCREEN_CAST_PROXY))

typedef struct _XdpImplScreenCastProxy XdpImplScreenCastProxy;
typedef struct _XdpImplScreenCastProxyClass XdpImplScreenCastProxyClass;
typedef struct _XdpImplScreenCastProxyPrivate XdpImplScreenCastProxyPrivate;

struct _XdpImplScreenCastProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplScreenCastProxyPrivate *priv;
};

struct _XdpImplScreenCastProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_screen_cast_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_screen_cast_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplScreenCast *xdp_impl_screen_cast_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplScreenCast *xdp_impl_screen_cast_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplScreenCast *xdp_impl_screen_cast_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplScreenCast *xdp_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_IMPL_TYPE_SCREEN_CAST_SKELETON (xdp_impl_screen_cast_skeleton_get_type ())
#define XDP_IMPL_SCREEN_CAST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SCREEN_CAST_SKELETON, XdpImplScreenCastSkeleton))
#define XDP_IMPL_SCREEN_CAST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_SCREEN_CAST_SKELETON, XdpImplScreenCastSkeletonClass))
#define XDP_IMPL_SCREEN_CAST_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_SCREEN_CAST_SKELETON, XdpImplScreenCastSkeletonClass))
#define XDP_IMPL_IS_SCREEN_CAST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SCREEN_CAST_SKELETON))
#define XDP_IMPL_IS_SCREEN_CAST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_SCREEN_CAST_SKELETON))

typedef struct _XdpImplScreenCastSkeleton XdpImplScreenCastSkeleton;
typedef struct _XdpImplScreenCastSkeletonClass XdpImplScreenCastSkeletonClass;
typedef struct _XdpImplScreenCastSkeletonPrivate XdpImplScreenCastSkeletonPrivate;

struct _XdpImplScreenCastSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplScreenCastSkeletonPrivate *priv;
};

struct _XdpImplScreenCastSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_screen_cast_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplScreenCast *xdp_impl_screen_cast_skeleton_new (void);


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

#define XDP_IMPL_TYPE_SCREENSHOT (xdp_impl_screenshot_get_type ())
#define XDP_IMPL_SCREENSHOT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SCREENSHOT, XdpImplScreenshot))
#define XDP_IMPL_IS_SCREENSHOT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SCREENSHOT))
#define XDP_IMPL_SCREENSHOT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_SCREENSHOT, XdpImplScreenshotIface))

struct _XdpImplScreenshot;
typedef struct _XdpImplScreenshot XdpImplScreenshot;
typedef struct _XdpImplScreenshotIface XdpImplScreenshotIface;

struct _XdpImplScreenshotIface
{
  GTypeInterface parent_iface;


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

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

  guint  (*get_version) (XdpImplScreenshot *object);

};

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

GType xdp_impl_screenshot_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_screenshot_interface_info (void);
guint xdp_impl_screenshot_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_screenshot_complete_pick_color (
    XdpImplScreenshot *object,
    GDBusMethodInvocation *invocation,
    guint response,
    GVariant *results);



/* D-Bus method calls: */
void xdp_impl_screenshot_call_screenshot (
    XdpImplScreenshot *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_impl_screenshot_call_screenshot_finish (
    XdpImplScreenshot *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_screenshot_call_screenshot_sync (
    XdpImplScreenshot *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_impl_screenshot_call_pick_color (
    XdpImplScreenshot *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_impl_screenshot_call_pick_color_finish (
    XdpImplScreenshot *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_screenshot_call_pick_color_sync (
    XdpImplScreenshot *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_impl_screenshot_get_version (XdpImplScreenshot *object);
void xdp_impl_screenshot_set_version (XdpImplScreenshot *object, guint value);


/* ---- */

#define XDP_IMPL_TYPE_SCREENSHOT_PROXY (xdp_impl_screenshot_proxy_get_type ())
#define XDP_IMPL_SCREENSHOT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SCREENSHOT_PROXY, XdpImplScreenshotProxy))
#define XDP_IMPL_SCREENSHOT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_SCREENSHOT_PROXY, XdpImplScreenshotProxyClass))
#define XDP_IMPL_SCREENSHOT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_SCREENSHOT_PROXY, XdpImplScreenshotProxyClass))
#define XDP_IMPL_IS_SCREENSHOT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SCREENSHOT_PROXY))
#define XDP_IMPL_IS_SCREENSHOT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_SCREENSHOT_PROXY))

typedef struct _XdpImplScreenshotProxy XdpImplScreenshotProxy;
typedef struct _XdpImplScreenshotProxyClass XdpImplScreenshotProxyClass;
typedef struct _XdpImplScreenshotProxyPrivate XdpImplScreenshotProxyPrivate;

struct _XdpImplScreenshotProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplScreenshotProxyPrivate *priv;
};

struct _XdpImplScreenshotProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_screenshot_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_screenshot_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplScreenshot *xdp_impl_screenshot_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplScreenshot *xdp_impl_screenshot_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplScreenshot *xdp_impl_screenshot_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplScreenshot *xdp_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_IMPL_TYPE_SCREENSHOT_SKELETON (xdp_impl_screenshot_skeleton_get_type ())
#define XDP_IMPL_SCREENSHOT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SCREENSHOT_SKELETON, XdpImplScreenshotSkeleton))
#define XDP_IMPL_SCREENSHOT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_SCREENSHOT_SKELETON, XdpImplScreenshotSkeletonClass))
#define XDP_IMPL_SCREENSHOT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_SCREENSHOT_SKELETON, XdpImplScreenshotSkeletonClass))
#define XDP_IMPL_IS_SCREENSHOT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SCREENSHOT_SKELETON))
#define XDP_IMPL_IS_SCREENSHOT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_SCREENSHOT_SKELETON))

typedef struct _XdpImplScreenshotSkeleton XdpImplScreenshotSkeleton;
typedef struct _XdpImplScreenshotSkeletonClass XdpImplScreenshotSkeletonClass;
typedef struct _XdpImplScreenshotSkeletonPrivate XdpImplScreenshotSkeletonPrivate;

struct _XdpImplScreenshotSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplScreenshotSkeletonPrivate *priv;
};

struct _XdpImplScreenshotSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_screenshot_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplScreenshot *xdp_impl_screenshot_skeleton_new (void);


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

#define XDP_IMPL_TYPE_SESSION (xdp_impl_session_get_type ())
#define XDP_IMPL_SESSION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SESSION, XdpImplSession))
#define XDP_IMPL_IS_SESSION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SESSION))
#define XDP_IMPL_SESSION_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_SESSION, XdpImplSessionIface))

struct _XdpImplSession;
typedef struct _XdpImplSession XdpImplSession;
typedef struct _XdpImplSessionIface XdpImplSessionIface;

struct _XdpImplSessionIface
{
  GTypeInterface parent_iface;



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

  guint  (*get_version) (XdpImplSession *object);

  void (*closed) (
    XdpImplSession *object);

};

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

GType xdp_impl_session_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_session_interface_info (void);
guint xdp_impl_session_override_properties (GObjectClass *klass, guint property_id_begin);


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



/* D-Bus signal emissions functions: */
void xdp_impl_session_emit_closed (
    XdpImplSession *object);



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

gboolean xdp_impl_session_call_close_finish (
    XdpImplSession *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_session_call_close_sync (
    XdpImplSession *proxy,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_impl_session_get_version (XdpImplSession *object);
void xdp_impl_session_set_version (XdpImplSession *object, guint value);


/* ---- */

#define XDP_IMPL_TYPE_SESSION_PROXY (xdp_impl_session_proxy_get_type ())
#define XDP_IMPL_SESSION_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SESSION_PROXY, XdpImplSessionProxy))
#define XDP_IMPL_SESSION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_SESSION_PROXY, XdpImplSessionProxyClass))
#define XDP_IMPL_SESSION_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_SESSION_PROXY, XdpImplSessionProxyClass))
#define XDP_IMPL_IS_SESSION_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SESSION_PROXY))
#define XDP_IMPL_IS_SESSION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_SESSION_PROXY))

typedef struct _XdpImplSessionProxy XdpImplSessionProxy;
typedef struct _XdpImplSessionProxyClass XdpImplSessionProxyClass;
typedef struct _XdpImplSessionProxyPrivate XdpImplSessionProxyPrivate;

struct _XdpImplSessionProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplSessionProxyPrivate *priv;
};

struct _XdpImplSessionProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_session_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_session_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplSession *xdp_impl_session_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplSession *xdp_impl_session_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplSession *xdp_impl_session_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplSession *xdp_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_IMPL_TYPE_SESSION_SKELETON (xdp_impl_session_skeleton_get_type ())
#define XDP_IMPL_SESSION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SESSION_SKELETON, XdpImplSessionSkeleton))
#define XDP_IMPL_SESSION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_SESSION_SKELETON, XdpImplSessionSkeletonClass))
#define XDP_IMPL_SESSION_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_SESSION_SKELETON, XdpImplSessionSkeletonClass))
#define XDP_IMPL_IS_SESSION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SESSION_SKELETON))
#define XDP_IMPL_IS_SESSION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_SESSION_SKELETON))

typedef struct _XdpImplSessionSkeleton XdpImplSessionSkeleton;
typedef struct _XdpImplSessionSkeletonClass XdpImplSessionSkeletonClass;
typedef struct _XdpImplSessionSkeletonPrivate XdpImplSessionSkeletonPrivate;

struct _XdpImplSessionSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplSessionSkeletonPrivate *priv;
};

struct _XdpImplSessionSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_session_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplSession *xdp_impl_session_skeleton_new (void);


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

#define XDP_IMPL_TYPE_SETTINGS (xdp_impl_settings_get_type ())
#define XDP_IMPL_SETTINGS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SETTINGS, XdpImplSettings))
#define XDP_IMPL_IS_SETTINGS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SETTINGS))
#define XDP_IMPL_SETTINGS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_SETTINGS, XdpImplSettingsIface))

struct _XdpImplSettings;
typedef struct _XdpImplSettings XdpImplSettings;
typedef struct _XdpImplSettingsIface XdpImplSettingsIface;

struct _XdpImplSettingsIface
{
  GTypeInterface parent_iface;



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

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

  guint  (*get_version) (XdpImplSettings *object);

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

};

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

GType xdp_impl_settings_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_settings_interface_info (void);
guint xdp_impl_settings_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_settings_complete_read (
    XdpImplSettings *object,
    GDBusMethodInvocation *invocation,
    GVariant *value);



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



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

gboolean xdp_impl_settings_call_read_all_finish (
    XdpImplSettings *proxy,
    GVariant ** out_value,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_impl_settings_call_read_finish (
    XdpImplSettings *proxy,
    GVariant ** out_value,
    GAsyncResult *res,
    GError **error);

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



/* D-Bus property accessors: */
guint xdp_impl_settings_get_version (XdpImplSettings *object);
void xdp_impl_settings_set_version (XdpImplSettings *object, guint value);


/* ---- */

#define XDP_IMPL_TYPE_SETTINGS_PROXY (xdp_impl_settings_proxy_get_type ())
#define XDP_IMPL_SETTINGS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SETTINGS_PROXY, XdpImplSettingsProxy))
#define XDP_IMPL_SETTINGS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_SETTINGS_PROXY, XdpImplSettingsProxyClass))
#define XDP_IMPL_SETTINGS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_SETTINGS_PROXY, XdpImplSettingsProxyClass))
#define XDP_IMPL_IS_SETTINGS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SETTINGS_PROXY))
#define XDP_IMPL_IS_SETTINGS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_SETTINGS_PROXY))

typedef struct _XdpImplSettingsProxy XdpImplSettingsProxy;
typedef struct _XdpImplSettingsProxyClass XdpImplSettingsProxyClass;
typedef struct _XdpImplSettingsProxyPrivate XdpImplSettingsProxyPrivate;

struct _XdpImplSettingsProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplSettingsProxyPrivate *priv;
};

struct _XdpImplSettingsProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_settings_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_settings_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplSettings *xdp_impl_settings_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplSettings *xdp_impl_settings_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplSettings *xdp_impl_settings_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplSettings *xdp_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_IMPL_TYPE_SETTINGS_SKELETON (xdp_impl_settings_skeleton_get_type ())
#define XDP_IMPL_SETTINGS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SETTINGS_SKELETON, XdpImplSettingsSkeleton))
#define XDP_IMPL_SETTINGS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_SETTINGS_SKELETON, XdpImplSettingsSkeletonClass))
#define XDP_IMPL_SETTINGS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_SETTINGS_SKELETON, XdpImplSettingsSkeletonClass))
#define XDP_IMPL_IS_SETTINGS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SETTINGS_SKELETON))
#define XDP_IMPL_IS_SETTINGS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_SETTINGS_SKELETON))

typedef struct _XdpImplSettingsSkeleton XdpImplSettingsSkeleton;
typedef struct _XdpImplSettingsSkeletonClass XdpImplSettingsSkeletonClass;
typedef struct _XdpImplSettingsSkeletonPrivate XdpImplSettingsSkeletonPrivate;

struct _XdpImplSettingsSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplSettingsSkeletonPrivate *priv;
};

struct _XdpImplSettingsSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_settings_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplSettings *xdp_impl_settings_skeleton_new (void);


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

#define XDP_IMPL_TYPE_USB (xdp_impl_usb_get_type ())
#define XDP_IMPL_USB(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_USB, XdpImplUsb))
#define XDP_IMPL_IS_USB(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_USB))
#define XDP_IMPL_USB_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_USB, XdpImplUsbIface))

struct _XdpImplUsb;
typedef struct _XdpImplUsb XdpImplUsb;
typedef struct _XdpImplUsbIface XdpImplUsbIface;

struct _XdpImplUsbIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_acquire_devices) (
    XdpImplUsb *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) (XdpImplUsb *object);

};

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

GType xdp_impl_usb_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_usb_interface_info (void);
guint xdp_impl_usb_override_properties (GObjectClass *klass, guint property_id_begin);


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



/* D-Bus method calls: */
void xdp_impl_usb_call_acquire_devices (
    XdpImplUsb *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_impl_usb_call_acquire_devices_finish (
    XdpImplUsb *proxy,
    guint* out_response,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_usb_call_acquire_devices_sync (
    XdpImplUsb *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_impl_usb_get_version (XdpImplUsb *object);
void xdp_impl_usb_set_version (XdpImplUsb *object, guint value);


/* ---- */

#define XDP_IMPL_TYPE_USB_PROXY (xdp_impl_usb_proxy_get_type ())
#define XDP_IMPL_USB_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_USB_PROXY, XdpImplUsbProxy))
#define XDP_IMPL_USB_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_USB_PROXY, XdpImplUsbProxyClass))
#define XDP_IMPL_USB_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_USB_PROXY, XdpImplUsbProxyClass))
#define XDP_IMPL_IS_USB_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_USB_PROXY))
#define XDP_IMPL_IS_USB_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_USB_PROXY))

typedef struct _XdpImplUsbProxy XdpImplUsbProxy;
typedef struct _XdpImplUsbProxyClass XdpImplUsbProxyClass;
typedef struct _XdpImplUsbProxyPrivate XdpImplUsbProxyPrivate;

struct _XdpImplUsbProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplUsbProxyPrivate *priv;
};

struct _XdpImplUsbProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_usb_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_usb_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplUsb *xdp_impl_usb_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplUsb *xdp_impl_usb_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplUsb *xdp_impl_usb_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplUsb *xdp_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_IMPL_TYPE_USB_SKELETON (xdp_impl_usb_skeleton_get_type ())
#define XDP_IMPL_USB_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_USB_SKELETON, XdpImplUsbSkeleton))
#define XDP_IMPL_USB_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_USB_SKELETON, XdpImplUsbSkeletonClass))
#define XDP_IMPL_USB_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_USB_SKELETON, XdpImplUsbSkeletonClass))
#define XDP_IMPL_IS_USB_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_USB_SKELETON))
#define XDP_IMPL_IS_USB_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_USB_SKELETON))

typedef struct _XdpImplUsbSkeleton XdpImplUsbSkeleton;
typedef struct _XdpImplUsbSkeletonClass XdpImplUsbSkeletonClass;
typedef struct _XdpImplUsbSkeletonPrivate XdpImplUsbSkeletonPrivate;

struct _XdpImplUsbSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplUsbSkeletonPrivate *priv;
};

struct _XdpImplUsbSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_usb_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplUsb *xdp_impl_usb_skeleton_new (void);


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

#define XDP_IMPL_TYPE_WALLPAPER (xdp_impl_wallpaper_get_type ())
#define XDP_IMPL_WALLPAPER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_WALLPAPER, XdpImplWallpaper))
#define XDP_IMPL_IS_WALLPAPER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_WALLPAPER))
#define XDP_IMPL_WALLPAPER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_WALLPAPER, XdpImplWallpaperIface))

struct _XdpImplWallpaper;
typedef struct _XdpImplWallpaper XdpImplWallpaper;
typedef struct _XdpImplWallpaperIface XdpImplWallpaperIface;

struct _XdpImplWallpaperIface
{
  GTypeInterface parent_iface;

  gboolean (*handle_set_wallpaper_uri) (
    XdpImplWallpaper *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 (XdpImplWallpaper, g_object_unref)
#endif

GType xdp_impl_wallpaper_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_wallpaper_interface_info (void);
guint xdp_impl_wallpaper_override_properties (GObjectClass *klass, guint property_id_begin);


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



/* D-Bus method calls: */
void xdp_impl_wallpaper_call_set_wallpaper_uri (
    XdpImplWallpaper *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_impl_wallpaper_call_set_wallpaper_uri_finish (
    XdpImplWallpaper *proxy,
    guint* out_response,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_wallpaper_call_set_wallpaper_uri_sync (
    XdpImplWallpaper *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_IMPL_TYPE_WALLPAPER_PROXY (xdp_impl_wallpaper_proxy_get_type ())
#define XDP_IMPL_WALLPAPER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_WALLPAPER_PROXY, XdpImplWallpaperProxy))
#define XDP_IMPL_WALLPAPER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_WALLPAPER_PROXY, XdpImplWallpaperProxyClass))
#define XDP_IMPL_WALLPAPER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_WALLPAPER_PROXY, XdpImplWallpaperProxyClass))
#define XDP_IMPL_IS_WALLPAPER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_WALLPAPER_PROXY))
#define XDP_IMPL_IS_WALLPAPER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_WALLPAPER_PROXY))

typedef struct _XdpImplWallpaperProxy XdpImplWallpaperProxy;
typedef struct _XdpImplWallpaperProxyClass XdpImplWallpaperProxyClass;
typedef struct _XdpImplWallpaperProxyPrivate XdpImplWallpaperProxyPrivate;

struct _XdpImplWallpaperProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplWallpaperProxyPrivate *priv;
};

struct _XdpImplWallpaperProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_wallpaper_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_wallpaper_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplWallpaper *xdp_impl_wallpaper_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplWallpaper *xdp_impl_wallpaper_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_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);
XdpImplWallpaper *xdp_impl_wallpaper_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplWallpaper *xdp_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_IMPL_TYPE_WALLPAPER_SKELETON (xdp_impl_wallpaper_skeleton_get_type ())
#define XDP_IMPL_WALLPAPER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_WALLPAPER_SKELETON, XdpImplWallpaperSkeleton))
#define XDP_IMPL_WALLPAPER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_WALLPAPER_SKELETON, XdpImplWallpaperSkeletonClass))
#define XDP_IMPL_WALLPAPER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_WALLPAPER_SKELETON, XdpImplWallpaperSkeletonClass))
#define XDP_IMPL_IS_WALLPAPER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_WALLPAPER_SKELETON))
#define XDP_IMPL_IS_WALLPAPER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_WALLPAPER_SKELETON))

typedef struct _XdpImplWallpaperSkeleton XdpImplWallpaperSkeleton;
typedef struct _XdpImplWallpaperSkeletonClass XdpImplWallpaperSkeletonClass;
typedef struct _XdpImplWallpaperSkeletonPrivate XdpImplWallpaperSkeletonPrivate;

struct _XdpImplWallpaperSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplWallpaperSkeletonPrivate *priv;
};

struct _XdpImplWallpaperSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_wallpaper_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplWallpaper *xdp_impl_wallpaper_skeleton_new (void);


G_END_DECLS

#endif /* __XDG_DESKTOP_PORTAL_DBUS_H__ */
