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

#ifndef __XDP_DBUS_H__
#define __XDP_DBUS_H__

#include <gio/gio.h>

G_BEGIN_DECLS


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

#define XDP_DBUS_TYPE_ACCOUNT (xdp_dbus_account_get_type ())
#define XDP_DBUS_ACCOUNT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_ACCOUNT, XdpDbusAccount))
#define XDP_DBUS_IS_ACCOUNT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_ACCOUNT))
#define XDP_DBUS_ACCOUNT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_ACCOUNT, XdpDbusAccountIface))

struct _XdpDbusAccount;
typedef struct _XdpDbusAccount XdpDbusAccount;
typedef struct _XdpDbusAccountIface XdpDbusAccountIface;

struct _XdpDbusAccountIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_get_user_information) (
    XdpDbusAccount *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_window,
    GVariant *arg_options);

  guint  (*get_version) (XdpDbusAccount *object);

};

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

GType xdp_dbus_account_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_account_interface_info (void);
guint xdp_dbus_account_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_account_complete_get_user_information (
    XdpDbusAccount *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);



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

gboolean xdp_dbus_account_call_get_user_information_finish (
    XdpDbusAccount *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_account_call_get_user_information_sync (
    XdpDbusAccount *proxy,
    const gchar *arg_window,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_account_get_version (XdpDbusAccount *object);
void xdp_dbus_account_set_version (XdpDbusAccount *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_ACCOUNT_PROXY (xdp_dbus_account_proxy_get_type ())
#define XDP_DBUS_ACCOUNT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_ACCOUNT_PROXY, XdpDbusAccountProxy))
#define XDP_DBUS_ACCOUNT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_ACCOUNT_PROXY, XdpDbusAccountProxyClass))
#define XDP_DBUS_ACCOUNT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_ACCOUNT_PROXY, XdpDbusAccountProxyClass))
#define XDP_DBUS_IS_ACCOUNT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_ACCOUNT_PROXY))
#define XDP_DBUS_IS_ACCOUNT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_ACCOUNT_PROXY))

typedef struct _XdpDbusAccountProxy XdpDbusAccountProxy;
typedef struct _XdpDbusAccountProxyClass XdpDbusAccountProxyClass;
typedef struct _XdpDbusAccountProxyPrivate XdpDbusAccountProxyPrivate;

struct _XdpDbusAccountProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusAccountProxyPrivate *priv;
};

struct _XdpDbusAccountProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_account_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_account_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusAccount *xdp_dbus_account_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusAccount *xdp_dbus_account_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_account_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusAccount *xdp_dbus_account_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusAccount *xdp_dbus_account_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_ACCOUNT_SKELETON (xdp_dbus_account_skeleton_get_type ())
#define XDP_DBUS_ACCOUNT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_ACCOUNT_SKELETON, XdpDbusAccountSkeleton))
#define XDP_DBUS_ACCOUNT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_ACCOUNT_SKELETON, XdpDbusAccountSkeletonClass))
#define XDP_DBUS_ACCOUNT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_ACCOUNT_SKELETON, XdpDbusAccountSkeletonClass))
#define XDP_DBUS_IS_ACCOUNT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_ACCOUNT_SKELETON))
#define XDP_DBUS_IS_ACCOUNT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_ACCOUNT_SKELETON))

typedef struct _XdpDbusAccountSkeleton XdpDbusAccountSkeleton;
typedef struct _XdpDbusAccountSkeletonClass XdpDbusAccountSkeletonClass;
typedef struct _XdpDbusAccountSkeletonPrivate XdpDbusAccountSkeletonPrivate;

struct _XdpDbusAccountSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusAccountSkeletonPrivate *priv;
};

struct _XdpDbusAccountSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_account_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusAccount *xdp_dbus_account_skeleton_new (void);


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

#define XDP_DBUS_TYPE_BACKGROUND (xdp_dbus_background_get_type ())
#define XDP_DBUS_BACKGROUND(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_BACKGROUND, XdpDbusBackground))
#define XDP_DBUS_IS_BACKGROUND(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_BACKGROUND))
#define XDP_DBUS_BACKGROUND_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_BACKGROUND, XdpDbusBackgroundIface))

struct _XdpDbusBackground;
typedef struct _XdpDbusBackground XdpDbusBackground;
typedef struct _XdpDbusBackgroundIface XdpDbusBackgroundIface;

struct _XdpDbusBackgroundIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_request_background) (
    XdpDbusBackground *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  gboolean (*handle_set_status) (
    XdpDbusBackground *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_options);

  guint  (*get_version) (XdpDbusBackground *object);

};

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

GType xdp_dbus_background_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_background_interface_info (void);
guint xdp_dbus_background_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_background_complete_request_background (
    XdpDbusBackground *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_background_complete_set_status (
    XdpDbusBackground *object,
    GDBusMethodInvocation *invocation);



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

gboolean xdp_dbus_background_call_request_background_finish (
    XdpDbusBackground *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_background_call_request_background_sync (
    XdpDbusBackground *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_background_call_set_status (
    XdpDbusBackground *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_background_call_set_status_finish (
    XdpDbusBackground *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_background_call_set_status_sync (
    XdpDbusBackground *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_background_get_version (XdpDbusBackground *object);
void xdp_dbus_background_set_version (XdpDbusBackground *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_BACKGROUND_PROXY (xdp_dbus_background_proxy_get_type ())
#define XDP_DBUS_BACKGROUND_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_BACKGROUND_PROXY, XdpDbusBackgroundProxy))
#define XDP_DBUS_BACKGROUND_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_BACKGROUND_PROXY, XdpDbusBackgroundProxyClass))
#define XDP_DBUS_BACKGROUND_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_BACKGROUND_PROXY, XdpDbusBackgroundProxyClass))
#define XDP_DBUS_IS_BACKGROUND_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_BACKGROUND_PROXY))
#define XDP_DBUS_IS_BACKGROUND_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_BACKGROUND_PROXY))

typedef struct _XdpDbusBackgroundProxy XdpDbusBackgroundProxy;
typedef struct _XdpDbusBackgroundProxyClass XdpDbusBackgroundProxyClass;
typedef struct _XdpDbusBackgroundProxyPrivate XdpDbusBackgroundProxyPrivate;

struct _XdpDbusBackgroundProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusBackgroundProxyPrivate *priv;
};

struct _XdpDbusBackgroundProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_background_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_background_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusBackground *xdp_dbus_background_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusBackground *xdp_dbus_background_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_background_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusBackground *xdp_dbus_background_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusBackground *xdp_dbus_background_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_BACKGROUND_SKELETON (xdp_dbus_background_skeleton_get_type ())
#define XDP_DBUS_BACKGROUND_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_BACKGROUND_SKELETON, XdpDbusBackgroundSkeleton))
#define XDP_DBUS_BACKGROUND_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_BACKGROUND_SKELETON, XdpDbusBackgroundSkeletonClass))
#define XDP_DBUS_BACKGROUND_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_BACKGROUND_SKELETON, XdpDbusBackgroundSkeletonClass))
#define XDP_DBUS_IS_BACKGROUND_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_BACKGROUND_SKELETON))
#define XDP_DBUS_IS_BACKGROUND_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_BACKGROUND_SKELETON))

typedef struct _XdpDbusBackgroundSkeleton XdpDbusBackgroundSkeleton;
typedef struct _XdpDbusBackgroundSkeletonClass XdpDbusBackgroundSkeletonClass;
typedef struct _XdpDbusBackgroundSkeletonPrivate XdpDbusBackgroundSkeletonPrivate;

struct _XdpDbusBackgroundSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusBackgroundSkeletonPrivate *priv;
};

struct _XdpDbusBackgroundSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_background_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusBackground *xdp_dbus_background_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.Camera */

#define XDP_DBUS_TYPE_CAMERA (xdp_dbus_camera_get_type ())
#define XDP_DBUS_CAMERA(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_CAMERA, XdpDbusCamera))
#define XDP_DBUS_IS_CAMERA(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_CAMERA))
#define XDP_DBUS_CAMERA_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_CAMERA, XdpDbusCameraIface))

struct _XdpDbusCamera;
typedef struct _XdpDbusCamera XdpDbusCamera;
typedef struct _XdpDbusCameraIface XdpDbusCameraIface;

struct _XdpDbusCameraIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_access_camera) (
    XdpDbusCamera *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_options);

  gboolean (*handle_open_pipewire_remote) (
    XdpDbusCamera *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *arg_options);

  gboolean  (*get_is_camera_present) (XdpDbusCamera *object);

  guint  (*get_version) (XdpDbusCamera *object);

};

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

GType xdp_dbus_camera_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_camera_interface_info (void);
guint xdp_dbus_camera_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_camera_complete_access_camera (
    XdpDbusCamera *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_camera_complete_open_pipewire_remote (
    XdpDbusCamera *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);



/* D-Bus method calls: */
void xdp_dbus_camera_call_access_camera (
    XdpDbusCamera *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_camera_call_access_camera_finish (
    XdpDbusCamera *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_camera_call_access_camera_sync (
    XdpDbusCamera *proxy,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_camera_call_open_pipewire_remote (
    XdpDbusCamera *proxy,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_camera_call_open_pipewire_remote_finish (
    XdpDbusCamera *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_camera_call_open_pipewire_remote_sync (
    XdpDbusCamera *proxy,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
gboolean xdp_dbus_camera_get_is_camera_present (XdpDbusCamera *object);
void xdp_dbus_camera_set_is_camera_present (XdpDbusCamera *object, gboolean value);

guint xdp_dbus_camera_get_version (XdpDbusCamera *object);
void xdp_dbus_camera_set_version (XdpDbusCamera *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_CAMERA_PROXY (xdp_dbus_camera_proxy_get_type ())
#define XDP_DBUS_CAMERA_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_CAMERA_PROXY, XdpDbusCameraProxy))
#define XDP_DBUS_CAMERA_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_CAMERA_PROXY, XdpDbusCameraProxyClass))
#define XDP_DBUS_CAMERA_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_CAMERA_PROXY, XdpDbusCameraProxyClass))
#define XDP_DBUS_IS_CAMERA_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_CAMERA_PROXY))
#define XDP_DBUS_IS_CAMERA_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_CAMERA_PROXY))

typedef struct _XdpDbusCameraProxy XdpDbusCameraProxy;
typedef struct _XdpDbusCameraProxyClass XdpDbusCameraProxyClass;
typedef struct _XdpDbusCameraProxyPrivate XdpDbusCameraProxyPrivate;

struct _XdpDbusCameraProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusCameraProxyPrivate *priv;
};

struct _XdpDbusCameraProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_camera_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_camera_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusCamera *xdp_dbus_camera_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusCamera *xdp_dbus_camera_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_camera_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusCamera *xdp_dbus_camera_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusCamera *xdp_dbus_camera_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_CAMERA_SKELETON (xdp_dbus_camera_skeleton_get_type ())
#define XDP_DBUS_CAMERA_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_CAMERA_SKELETON, XdpDbusCameraSkeleton))
#define XDP_DBUS_CAMERA_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_CAMERA_SKELETON, XdpDbusCameraSkeletonClass))
#define XDP_DBUS_CAMERA_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_CAMERA_SKELETON, XdpDbusCameraSkeletonClass))
#define XDP_DBUS_IS_CAMERA_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_CAMERA_SKELETON))
#define XDP_DBUS_IS_CAMERA_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_CAMERA_SKELETON))

typedef struct _XdpDbusCameraSkeleton XdpDbusCameraSkeleton;
typedef struct _XdpDbusCameraSkeletonClass XdpDbusCameraSkeletonClass;
typedef struct _XdpDbusCameraSkeletonPrivate XdpDbusCameraSkeletonPrivate;

struct _XdpDbusCameraSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusCameraSkeletonPrivate *priv;
};

struct _XdpDbusCameraSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_camera_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusCamera *xdp_dbus_camera_skeleton_new (void);


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

#define XDP_DBUS_TYPE_CLIPBOARD (xdp_dbus_clipboard_get_type ())
#define XDP_DBUS_CLIPBOARD(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_CLIPBOARD, XdpDbusClipboard))
#define XDP_DBUS_IS_CLIPBOARD(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_CLIPBOARD))
#define XDP_DBUS_CLIPBOARD_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_CLIPBOARD, XdpDbusClipboardIface))

struct _XdpDbusClipboard;
typedef struct _XdpDbusClipboard XdpDbusClipboard;
typedef struct _XdpDbusClipboardIface XdpDbusClipboardIface;

struct _XdpDbusClipboardIface
{
  GTypeInterface parent_iface;



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

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

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

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

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

  guint  (*get_version) (XdpDbusClipboard *object);

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

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

GType xdp_dbus_clipboard_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_clipboard_interface_info (void);
guint xdp_dbus_clipboard_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_dbus_clipboard_complete_set_selection (
    XdpDbusClipboard *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_clipboard_complete_selection_write (
    XdpDbusClipboard *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);

void xdp_dbus_clipboard_complete_selection_write_done (
    XdpDbusClipboard *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_clipboard_complete_selection_read (
    XdpDbusClipboard *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);



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

void xdp_dbus_clipboard_emit_selection_transfer (
    XdpDbusClipboard *object,
    const gchar *arg_session_handle,
    const gchar *arg_mime_type,
    guint arg_serial);



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

gboolean xdp_dbus_clipboard_call_request_clipboard_finish (
    XdpDbusClipboard *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_clipboard_call_set_selection_finish (
    XdpDbusClipboard *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_clipboard_call_selection_write_finish (
    XdpDbusClipboard *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_clipboard_call_selection_write_done_finish (
    XdpDbusClipboard *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_clipboard_call_selection_read_finish (
    XdpDbusClipboard *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

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



/* D-Bus property accessors: */
guint xdp_dbus_clipboard_get_version (XdpDbusClipboard *object);
void xdp_dbus_clipboard_set_version (XdpDbusClipboard *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_CLIPBOARD_PROXY (xdp_dbus_clipboard_proxy_get_type ())
#define XDP_DBUS_CLIPBOARD_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_CLIPBOARD_PROXY, XdpDbusClipboardProxy))
#define XDP_DBUS_CLIPBOARD_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_CLIPBOARD_PROXY, XdpDbusClipboardProxyClass))
#define XDP_DBUS_CLIPBOARD_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_CLIPBOARD_PROXY, XdpDbusClipboardProxyClass))
#define XDP_DBUS_IS_CLIPBOARD_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_CLIPBOARD_PROXY))
#define XDP_DBUS_IS_CLIPBOARD_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_CLIPBOARD_PROXY))

typedef struct _XdpDbusClipboardProxy XdpDbusClipboardProxy;
typedef struct _XdpDbusClipboardProxyClass XdpDbusClipboardProxyClass;
typedef struct _XdpDbusClipboardProxyPrivate XdpDbusClipboardProxyPrivate;

struct _XdpDbusClipboardProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusClipboardProxyPrivate *priv;
};

struct _XdpDbusClipboardProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_clipboard_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_clipboard_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusClipboard *xdp_dbus_clipboard_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusClipboard *xdp_dbus_clipboard_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_clipboard_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusClipboard *xdp_dbus_clipboard_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusClipboard *xdp_dbus_clipboard_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_CLIPBOARD_SKELETON (xdp_dbus_clipboard_skeleton_get_type ())
#define XDP_DBUS_CLIPBOARD_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_CLIPBOARD_SKELETON, XdpDbusClipboardSkeleton))
#define XDP_DBUS_CLIPBOARD_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_CLIPBOARD_SKELETON, XdpDbusClipboardSkeletonClass))
#define XDP_DBUS_CLIPBOARD_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_CLIPBOARD_SKELETON, XdpDbusClipboardSkeletonClass))
#define XDP_DBUS_IS_CLIPBOARD_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_CLIPBOARD_SKELETON))
#define XDP_DBUS_IS_CLIPBOARD_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_CLIPBOARD_SKELETON))

typedef struct _XdpDbusClipboardSkeleton XdpDbusClipboardSkeleton;
typedef struct _XdpDbusClipboardSkeletonClass XdpDbusClipboardSkeletonClass;
typedef struct _XdpDbusClipboardSkeletonPrivate XdpDbusClipboardSkeletonPrivate;

struct _XdpDbusClipboardSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusClipboardSkeletonPrivate *priv;
};

struct _XdpDbusClipboardSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_clipboard_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusClipboard *xdp_dbus_clipboard_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.Documents */

#define XDP_DBUS_TYPE_DOCUMENTS (xdp_dbus_documents_get_type ())
#define XDP_DBUS_DOCUMENTS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_DOCUMENTS, XdpDbusDocuments))
#define XDP_DBUS_IS_DOCUMENTS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_DOCUMENTS))
#define XDP_DBUS_DOCUMENTS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_DOCUMENTS, XdpDbusDocumentsIface))

struct _XdpDbusDocuments;
typedef struct _XdpDbusDocuments XdpDbusDocuments;
typedef struct _XdpDbusDocumentsIface XdpDbusDocumentsIface;

struct _XdpDbusDocumentsIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_add) (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *arg_o_path_fd,
    gboolean arg_reuse_existing,
    gboolean arg_persistent);

  gboolean (*handle_add_full) (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *arg_o_path_fds,
    guint arg_flags,
    const gchar *arg_app_id,
    const gchar *const *arg_permissions);

  gboolean (*handle_add_named) (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *arg_o_path_parent_fd,
    const gchar *arg_filename,
    gboolean arg_reuse_existing,
    gboolean arg_persistent);

  gboolean (*handle_add_named_full) (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *arg_o_path_fd,
    const gchar *arg_filename,
    guint arg_flags,
    const gchar *arg_app_id,
    const gchar *const *arg_permissions);

  gboolean (*handle_delete) (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_doc_id);

  gboolean (*handle_get_host_paths) (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *arg_doc_ids);

  gboolean (*handle_get_mount_point) (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_grant_permissions) (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_doc_id,
    const gchar *arg_app_id,
    const gchar *const *arg_permissions);

  gboolean (*handle_info) (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_doc_id);

  gboolean (*handle_list) (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_app_id);

  gboolean (*handle_lookup) (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_filename);

  gboolean (*handle_revoke_permissions) (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_doc_id,
    const gchar *arg_app_id,
    const gchar *const *arg_permissions);

  guint  (*get_version) (XdpDbusDocuments *object);

};

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

GType xdp_dbus_documents_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_documents_interface_info (void);
guint xdp_dbus_documents_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_documents_complete_get_mount_point (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    const gchar *path);

void xdp_dbus_documents_complete_add (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *doc_id);

void xdp_dbus_documents_complete_add_named (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *doc_id);

void xdp_dbus_documents_complete_add_full (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *const *doc_ids,
    GVariant *extra_out);

void xdp_dbus_documents_complete_add_named_full (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *doc_id,
    GVariant *extra_out);

void xdp_dbus_documents_complete_grant_permissions (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_documents_complete_revoke_permissions (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_documents_complete_delete (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_documents_complete_lookup (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    const gchar *doc_id);

void xdp_dbus_documents_complete_info (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    const gchar *path,
    GVariant *apps);

void xdp_dbus_documents_complete_list (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    GVariant *docs);

void xdp_dbus_documents_complete_get_host_paths (
    XdpDbusDocuments *object,
    GDBusMethodInvocation *invocation,
    GVariant *paths);



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

gboolean xdp_dbus_documents_call_get_mount_point_finish (
    XdpDbusDocuments *proxy,
    gchar ** out_path,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_documents_call_get_mount_point_sync (
    XdpDbusDocuments *proxy,
    gchar ** out_path,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_documents_call_add (
    XdpDbusDocuments *proxy,
    GVariant *arg_o_path_fd,
    gboolean arg_reuse_existing,
    gboolean arg_persistent,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_documents_call_add_finish (
    XdpDbusDocuments *proxy,
    gchar ** out_doc_id,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_documents_call_add_sync (
    XdpDbusDocuments *proxy,
    GVariant *arg_o_path_fd,
    gboolean arg_reuse_existing,
    gboolean arg_persistent,
    GUnixFDList  *fd_list,
    gchar ** out_doc_id,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_documents_call_add_named (
    XdpDbusDocuments *proxy,
    GVariant *arg_o_path_parent_fd,
    const gchar *arg_filename,
    gboolean arg_reuse_existing,
    gboolean arg_persistent,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_documents_call_add_named_finish (
    XdpDbusDocuments *proxy,
    gchar ** out_doc_id,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_documents_call_add_named_sync (
    XdpDbusDocuments *proxy,
    GVariant *arg_o_path_parent_fd,
    const gchar *arg_filename,
    gboolean arg_reuse_existing,
    gboolean arg_persistent,
    GUnixFDList  *fd_list,
    gchar ** out_doc_id,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_documents_call_add_full (
    XdpDbusDocuments *proxy,
    GVariant *arg_o_path_fds,
    guint arg_flags,
    const gchar *arg_app_id,
    const gchar *const *arg_permissions,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_documents_call_add_full_finish (
    XdpDbusDocuments *proxy,
    gchar *** out_doc_ids,
    GVariant ** out_extra_out,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_documents_call_add_full_sync (
    XdpDbusDocuments *proxy,
    GVariant *arg_o_path_fds,
    guint arg_flags,
    const gchar *arg_app_id,
    const gchar *const *arg_permissions,
    GUnixFDList  *fd_list,
    gchar *** out_doc_ids,
    GVariant ** out_extra_out,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_documents_call_add_named_full (
    XdpDbusDocuments *proxy,
    GVariant *arg_o_path_fd,
    const gchar *arg_filename,
    guint arg_flags,
    const gchar *arg_app_id,
    const gchar *const *arg_permissions,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_documents_call_add_named_full_finish (
    XdpDbusDocuments *proxy,
    gchar ** out_doc_id,
    GVariant ** out_extra_out,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_documents_call_add_named_full_sync (
    XdpDbusDocuments *proxy,
    GVariant *arg_o_path_fd,
    const gchar *arg_filename,
    guint arg_flags,
    const gchar *arg_app_id,
    const gchar *const *arg_permissions,
    GUnixFDList  *fd_list,
    gchar ** out_doc_id,
    GVariant ** out_extra_out,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_documents_call_grant_permissions (
    XdpDbusDocuments *proxy,
    const gchar *arg_doc_id,
    const gchar *arg_app_id,
    const gchar *const *arg_permissions,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_documents_call_grant_permissions_finish (
    XdpDbusDocuments *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_documents_call_grant_permissions_sync (
    XdpDbusDocuments *proxy,
    const gchar *arg_doc_id,
    const gchar *arg_app_id,
    const gchar *const *arg_permissions,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_documents_call_revoke_permissions (
    XdpDbusDocuments *proxy,
    const gchar *arg_doc_id,
    const gchar *arg_app_id,
    const gchar *const *arg_permissions,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_documents_call_revoke_permissions_finish (
    XdpDbusDocuments *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_documents_call_revoke_permissions_sync (
    XdpDbusDocuments *proxy,
    const gchar *arg_doc_id,
    const gchar *arg_app_id,
    const gchar *const *arg_permissions,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_documents_call_delete (
    XdpDbusDocuments *proxy,
    const gchar *arg_doc_id,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_documents_call_delete_finish (
    XdpDbusDocuments *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_documents_call_delete_sync (
    XdpDbusDocuments *proxy,
    const gchar *arg_doc_id,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_documents_call_lookup (
    XdpDbusDocuments *proxy,
    const gchar *arg_filename,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_documents_call_lookup_finish (
    XdpDbusDocuments *proxy,
    gchar ** out_doc_id,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_documents_call_lookup_sync (
    XdpDbusDocuments *proxy,
    const gchar *arg_filename,
    gchar ** out_doc_id,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_documents_call_info (
    XdpDbusDocuments *proxy,
    const gchar *arg_doc_id,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_documents_call_info_finish (
    XdpDbusDocuments *proxy,
    gchar ** out_path,
    GVariant ** out_apps,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_documents_call_info_sync (
    XdpDbusDocuments *proxy,
    const gchar *arg_doc_id,
    gchar ** out_path,
    GVariant ** out_apps,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_documents_call_list (
    XdpDbusDocuments *proxy,
    const gchar *arg_app_id,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_documents_call_list_finish (
    XdpDbusDocuments *proxy,
    GVariant ** out_docs,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_documents_call_list_sync (
    XdpDbusDocuments *proxy,
    const gchar *arg_app_id,
    GVariant ** out_docs,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_documents_call_get_host_paths (
    XdpDbusDocuments *proxy,
    const gchar *const *arg_doc_ids,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_documents_call_get_host_paths_finish (
    XdpDbusDocuments *proxy,
    GVariant ** out_paths,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_documents_call_get_host_paths_sync (
    XdpDbusDocuments *proxy,
    const gchar *const *arg_doc_ids,
    GVariant ** out_paths,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_documents_get_version (XdpDbusDocuments *object);
void xdp_dbus_documents_set_version (XdpDbusDocuments *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_DOCUMENTS_PROXY (xdp_dbus_documents_proxy_get_type ())
#define XDP_DBUS_DOCUMENTS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_DOCUMENTS_PROXY, XdpDbusDocumentsProxy))
#define XDP_DBUS_DOCUMENTS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_DOCUMENTS_PROXY, XdpDbusDocumentsProxyClass))
#define XDP_DBUS_DOCUMENTS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_DOCUMENTS_PROXY, XdpDbusDocumentsProxyClass))
#define XDP_DBUS_IS_DOCUMENTS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_DOCUMENTS_PROXY))
#define XDP_DBUS_IS_DOCUMENTS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_DOCUMENTS_PROXY))

typedef struct _XdpDbusDocumentsProxy XdpDbusDocumentsProxy;
typedef struct _XdpDbusDocumentsProxyClass XdpDbusDocumentsProxyClass;
typedef struct _XdpDbusDocumentsProxyPrivate XdpDbusDocumentsProxyPrivate;

struct _XdpDbusDocumentsProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusDocumentsProxyPrivate *priv;
};

struct _XdpDbusDocumentsProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_documents_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_documents_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusDocuments *xdp_dbus_documents_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusDocuments *xdp_dbus_documents_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_documents_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusDocuments *xdp_dbus_documents_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusDocuments *xdp_dbus_documents_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_DOCUMENTS_SKELETON (xdp_dbus_documents_skeleton_get_type ())
#define XDP_DBUS_DOCUMENTS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_DOCUMENTS_SKELETON, XdpDbusDocumentsSkeleton))
#define XDP_DBUS_DOCUMENTS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_DOCUMENTS_SKELETON, XdpDbusDocumentsSkeletonClass))
#define XDP_DBUS_DOCUMENTS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_DOCUMENTS_SKELETON, XdpDbusDocumentsSkeletonClass))
#define XDP_DBUS_IS_DOCUMENTS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_DOCUMENTS_SKELETON))
#define XDP_DBUS_IS_DOCUMENTS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_DOCUMENTS_SKELETON))

typedef struct _XdpDbusDocumentsSkeleton XdpDbusDocumentsSkeleton;
typedef struct _XdpDbusDocumentsSkeletonClass XdpDbusDocumentsSkeletonClass;
typedef struct _XdpDbusDocumentsSkeletonPrivate XdpDbusDocumentsSkeletonPrivate;

struct _XdpDbusDocumentsSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusDocumentsSkeletonPrivate *priv;
};

struct _XdpDbusDocumentsSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_documents_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusDocuments *xdp_dbus_documents_skeleton_new (void);


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

#define XDP_DBUS_TYPE_DYNAMIC_LAUNCHER (xdp_dbus_dynamic_launcher_get_type ())
#define XDP_DBUS_DYNAMIC_LAUNCHER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_DYNAMIC_LAUNCHER, XdpDbusDynamicLauncher))
#define XDP_DBUS_IS_DYNAMIC_LAUNCHER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_DYNAMIC_LAUNCHER))
#define XDP_DBUS_DYNAMIC_LAUNCHER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_DYNAMIC_LAUNCHER, XdpDbusDynamicLauncherIface))

struct _XdpDbusDynamicLauncher;
typedef struct _XdpDbusDynamicLauncher XdpDbusDynamicLauncher;
typedef struct _XdpDbusDynamicLauncherIface XdpDbusDynamicLauncherIface;

struct _XdpDbusDynamicLauncherIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_get_desktop_entry) (
    XdpDbusDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_desktop_file_id);

  gboolean (*handle_get_icon) (
    XdpDbusDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_desktop_file_id);

  gboolean (*handle_install) (
    XdpDbusDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_token,
    const gchar *arg_desktop_file_id,
    const gchar *arg_desktop_entry,
    GVariant *arg_options);

  gboolean (*handle_launch) (
    XdpDbusDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_desktop_file_id,
    GVariant *arg_options);

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

  gboolean (*handle_request_install_token) (
    XdpDbusDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_name,
    GVariant *arg_icon_v,
    GVariant *arg_options);

  gboolean (*handle_uninstall) (
    XdpDbusDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_desktop_file_id,
    GVariant *arg_options);

  guint  (*get_supported_launcher_types) (XdpDbusDynamicLauncher *object);

  guint  (*get_version) (XdpDbusDynamicLauncher *object);

};

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

GType xdp_dbus_dynamic_launcher_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_dynamic_launcher_interface_info (void);
guint xdp_dbus_dynamic_launcher_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_dbus_dynamic_launcher_complete_prepare_install (
    XdpDbusDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_dynamic_launcher_complete_request_install_token (
    XdpDbusDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    const gchar *token);

void xdp_dbus_dynamic_launcher_complete_uninstall (
    XdpDbusDynamicLauncher *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_dynamic_launcher_complete_get_desktop_entry (
    XdpDbusDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    const gchar *contents);

void xdp_dbus_dynamic_launcher_complete_get_icon (
    XdpDbusDynamicLauncher *object,
    GDBusMethodInvocation *invocation,
    GVariant *icon_v,
    const gchar *icon_format,
    guint icon_size);

void xdp_dbus_dynamic_launcher_complete_launch (
    XdpDbusDynamicLauncher *object,
    GDBusMethodInvocation *invocation);



/* D-Bus method calls: */
void xdp_dbus_dynamic_launcher_call_install (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_token,
    const gchar *arg_desktop_file_id,
    const gchar *arg_desktop_entry,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_dynamic_launcher_call_install_finish (
    XdpDbusDynamicLauncher *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_dynamic_launcher_call_install_sync (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_token,
    const gchar *arg_desktop_file_id,
    const gchar *arg_desktop_entry,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_dynamic_launcher_call_prepare_install (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_parent_window,
    const gchar *arg_name,
    GVariant *arg_icon_v,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_dynamic_launcher_call_prepare_install_finish (
    XdpDbusDynamicLauncher *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_dynamic_launcher_call_prepare_install_sync (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_parent_window,
    const gchar *arg_name,
    GVariant *arg_icon_v,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_dynamic_launcher_call_request_install_token (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_name,
    GVariant *arg_icon_v,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_dynamic_launcher_call_request_install_token_finish (
    XdpDbusDynamicLauncher *proxy,
    gchar ** out_token,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_dynamic_launcher_call_request_install_token_sync (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_name,
    GVariant *arg_icon_v,
    GVariant *arg_options,
    gchar ** out_token,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_dynamic_launcher_call_uninstall (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_desktop_file_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_dynamic_launcher_call_uninstall_finish (
    XdpDbusDynamicLauncher *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_dynamic_launcher_call_uninstall_sync (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_desktop_file_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_dynamic_launcher_call_get_desktop_entry (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_desktop_file_id,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_dynamic_launcher_call_get_desktop_entry_finish (
    XdpDbusDynamicLauncher *proxy,
    gchar ** out_contents,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_dynamic_launcher_call_get_desktop_entry_sync (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_desktop_file_id,
    gchar ** out_contents,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_dynamic_launcher_call_get_icon (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_desktop_file_id,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_dynamic_launcher_call_get_icon_finish (
    XdpDbusDynamicLauncher *proxy,
    GVariant ** out_icon_v,
    gchar ** out_icon_format,
    guint* out_icon_size,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_dynamic_launcher_call_get_icon_sync (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_desktop_file_id,
    GVariant ** out_icon_v,
    gchar ** out_icon_format,
    guint* out_icon_size,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_dynamic_launcher_call_launch (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_desktop_file_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_dynamic_launcher_call_launch_finish (
    XdpDbusDynamicLauncher *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_dynamic_launcher_call_launch_sync (
    XdpDbusDynamicLauncher *proxy,
    const gchar *arg_desktop_file_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_dynamic_launcher_get_supported_launcher_types (XdpDbusDynamicLauncher *object);
void xdp_dbus_dynamic_launcher_set_supported_launcher_types (XdpDbusDynamicLauncher *object, guint value);

guint xdp_dbus_dynamic_launcher_get_version (XdpDbusDynamicLauncher *object);
void xdp_dbus_dynamic_launcher_set_version (XdpDbusDynamicLauncher *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_DYNAMIC_LAUNCHER_PROXY (xdp_dbus_dynamic_launcher_proxy_get_type ())
#define XDP_DBUS_DYNAMIC_LAUNCHER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_DYNAMIC_LAUNCHER_PROXY, XdpDbusDynamicLauncherProxy))
#define XDP_DBUS_DYNAMIC_LAUNCHER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_DYNAMIC_LAUNCHER_PROXY, XdpDbusDynamicLauncherProxyClass))
#define XDP_DBUS_DYNAMIC_LAUNCHER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_DYNAMIC_LAUNCHER_PROXY, XdpDbusDynamicLauncherProxyClass))
#define XDP_DBUS_IS_DYNAMIC_LAUNCHER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_DYNAMIC_LAUNCHER_PROXY))
#define XDP_DBUS_IS_DYNAMIC_LAUNCHER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_DYNAMIC_LAUNCHER_PROXY))

typedef struct _XdpDbusDynamicLauncherProxy XdpDbusDynamicLauncherProxy;
typedef struct _XdpDbusDynamicLauncherProxyClass XdpDbusDynamicLauncherProxyClass;
typedef struct _XdpDbusDynamicLauncherProxyPrivate XdpDbusDynamicLauncherProxyPrivate;

struct _XdpDbusDynamicLauncherProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusDynamicLauncherProxyPrivate *priv;
};

struct _XdpDbusDynamicLauncherProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_dynamic_launcher_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_dynamic_launcher_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusDynamicLauncher *xdp_dbus_dynamic_launcher_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusDynamicLauncher *xdp_dbus_dynamic_launcher_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_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);
XdpDbusDynamicLauncher *xdp_dbus_dynamic_launcher_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusDynamicLauncher *xdp_dbus_dynamic_launcher_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_DYNAMIC_LAUNCHER_SKELETON (xdp_dbus_dynamic_launcher_skeleton_get_type ())
#define XDP_DBUS_DYNAMIC_LAUNCHER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_DYNAMIC_LAUNCHER_SKELETON, XdpDbusDynamicLauncherSkeleton))
#define XDP_DBUS_DYNAMIC_LAUNCHER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_DYNAMIC_LAUNCHER_SKELETON, XdpDbusDynamicLauncherSkeletonClass))
#define XDP_DBUS_DYNAMIC_LAUNCHER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_DYNAMIC_LAUNCHER_SKELETON, XdpDbusDynamicLauncherSkeletonClass))
#define XDP_DBUS_IS_DYNAMIC_LAUNCHER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_DYNAMIC_LAUNCHER_SKELETON))
#define XDP_DBUS_IS_DYNAMIC_LAUNCHER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_DYNAMIC_LAUNCHER_SKELETON))

typedef struct _XdpDbusDynamicLauncherSkeleton XdpDbusDynamicLauncherSkeleton;
typedef struct _XdpDbusDynamicLauncherSkeletonClass XdpDbusDynamicLauncherSkeletonClass;
typedef struct _XdpDbusDynamicLauncherSkeletonPrivate XdpDbusDynamicLauncherSkeletonPrivate;

struct _XdpDbusDynamicLauncherSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusDynamicLauncherSkeletonPrivate *priv;
};

struct _XdpDbusDynamicLauncherSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_dynamic_launcher_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusDynamicLauncher *xdp_dbus_dynamic_launcher_skeleton_new (void);


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

#define XDP_DBUS_TYPE_EMAIL (xdp_dbus_email_get_type ())
#define XDP_DBUS_EMAIL(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_EMAIL, XdpDbusEmail))
#define XDP_DBUS_IS_EMAIL(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_EMAIL))
#define XDP_DBUS_EMAIL_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_EMAIL, XdpDbusEmailIface))

struct _XdpDbusEmail;
typedef struct _XdpDbusEmail XdpDbusEmail;
typedef struct _XdpDbusEmailIface XdpDbusEmailIface;

struct _XdpDbusEmailIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_compose_email) (
    XdpDbusEmail *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  guint  (*get_version) (XdpDbusEmail *object);

};

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

GType xdp_dbus_email_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_email_interface_info (void);
guint xdp_dbus_email_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_email_complete_compose_email (
    XdpDbusEmail *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *handle);



/* D-Bus method calls: */
void xdp_dbus_email_call_compose_email (
    XdpDbusEmail *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_email_call_compose_email_finish (
    XdpDbusEmail *proxy,
    gchar ** out_handle,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_email_call_compose_email_sync (
    XdpDbusEmail *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    gchar ** out_handle,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_email_get_version (XdpDbusEmail *object);
void xdp_dbus_email_set_version (XdpDbusEmail *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_EMAIL_PROXY (xdp_dbus_email_proxy_get_type ())
#define XDP_DBUS_EMAIL_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_EMAIL_PROXY, XdpDbusEmailProxy))
#define XDP_DBUS_EMAIL_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_EMAIL_PROXY, XdpDbusEmailProxyClass))
#define XDP_DBUS_EMAIL_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_EMAIL_PROXY, XdpDbusEmailProxyClass))
#define XDP_DBUS_IS_EMAIL_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_EMAIL_PROXY))
#define XDP_DBUS_IS_EMAIL_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_EMAIL_PROXY))

typedef struct _XdpDbusEmailProxy XdpDbusEmailProxy;
typedef struct _XdpDbusEmailProxyClass XdpDbusEmailProxyClass;
typedef struct _XdpDbusEmailProxyPrivate XdpDbusEmailProxyPrivate;

struct _XdpDbusEmailProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusEmailProxyPrivate *priv;
};

struct _XdpDbusEmailProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_email_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_email_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusEmail *xdp_dbus_email_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusEmail *xdp_dbus_email_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_email_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusEmail *xdp_dbus_email_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusEmail *xdp_dbus_email_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_EMAIL_SKELETON (xdp_dbus_email_skeleton_get_type ())
#define XDP_DBUS_EMAIL_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_EMAIL_SKELETON, XdpDbusEmailSkeleton))
#define XDP_DBUS_EMAIL_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_EMAIL_SKELETON, XdpDbusEmailSkeletonClass))
#define XDP_DBUS_EMAIL_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_EMAIL_SKELETON, XdpDbusEmailSkeletonClass))
#define XDP_DBUS_IS_EMAIL_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_EMAIL_SKELETON))
#define XDP_DBUS_IS_EMAIL_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_EMAIL_SKELETON))

typedef struct _XdpDbusEmailSkeleton XdpDbusEmailSkeleton;
typedef struct _XdpDbusEmailSkeletonClass XdpDbusEmailSkeletonClass;
typedef struct _XdpDbusEmailSkeletonPrivate XdpDbusEmailSkeletonPrivate;

struct _XdpDbusEmailSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusEmailSkeletonPrivate *priv;
};

struct _XdpDbusEmailSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_email_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusEmail *xdp_dbus_email_skeleton_new (void);


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

#define XDP_DBUS_TYPE_FILE_CHOOSER (xdp_dbus_file_chooser_get_type ())
#define XDP_DBUS_FILE_CHOOSER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_FILE_CHOOSER, XdpDbusFileChooser))
#define XDP_DBUS_IS_FILE_CHOOSER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_FILE_CHOOSER))
#define XDP_DBUS_FILE_CHOOSER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_FILE_CHOOSER, XdpDbusFileChooserIface))

struct _XdpDbusFileChooser;
typedef struct _XdpDbusFileChooser XdpDbusFileChooser;
typedef struct _XdpDbusFileChooserIface XdpDbusFileChooserIface;

struct _XdpDbusFileChooserIface
{
  GTypeInterface parent_iface;


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

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

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

  guint  (*get_version) (XdpDbusFileChooser *object);

};

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

GType xdp_dbus_file_chooser_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_file_chooser_interface_info (void);
guint xdp_dbus_file_chooser_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_file_chooser_complete_open_file (
    XdpDbusFileChooser *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_file_chooser_complete_save_file (
    XdpDbusFileChooser *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_file_chooser_complete_save_files (
    XdpDbusFileChooser *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);



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

gboolean xdp_dbus_file_chooser_call_open_file_finish (
    XdpDbusFileChooser *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_file_chooser_call_open_file_sync (
    XdpDbusFileChooser *proxy,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_file_chooser_call_save_file (
    XdpDbusFileChooser *proxy,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_file_chooser_call_save_file_finish (
    XdpDbusFileChooser *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_file_chooser_call_save_file_sync (
    XdpDbusFileChooser *proxy,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_file_chooser_call_save_files (
    XdpDbusFileChooser *proxy,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_file_chooser_call_save_files_finish (
    XdpDbusFileChooser *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_file_chooser_call_save_files_sync (
    XdpDbusFileChooser *proxy,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_file_chooser_get_version (XdpDbusFileChooser *object);
void xdp_dbus_file_chooser_set_version (XdpDbusFileChooser *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_FILE_CHOOSER_PROXY (xdp_dbus_file_chooser_proxy_get_type ())
#define XDP_DBUS_FILE_CHOOSER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_FILE_CHOOSER_PROXY, XdpDbusFileChooserProxy))
#define XDP_DBUS_FILE_CHOOSER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_FILE_CHOOSER_PROXY, XdpDbusFileChooserProxyClass))
#define XDP_DBUS_FILE_CHOOSER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_FILE_CHOOSER_PROXY, XdpDbusFileChooserProxyClass))
#define XDP_DBUS_IS_FILE_CHOOSER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_FILE_CHOOSER_PROXY))
#define XDP_DBUS_IS_FILE_CHOOSER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_FILE_CHOOSER_PROXY))

typedef struct _XdpDbusFileChooserProxy XdpDbusFileChooserProxy;
typedef struct _XdpDbusFileChooserProxyClass XdpDbusFileChooserProxyClass;
typedef struct _XdpDbusFileChooserProxyPrivate XdpDbusFileChooserProxyPrivate;

struct _XdpDbusFileChooserProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusFileChooserProxyPrivate *priv;
};

struct _XdpDbusFileChooserProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_file_chooser_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_file_chooser_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusFileChooser *xdp_dbus_file_chooser_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusFileChooser *xdp_dbus_file_chooser_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_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);
XdpDbusFileChooser *xdp_dbus_file_chooser_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusFileChooser *xdp_dbus_file_chooser_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_FILE_CHOOSER_SKELETON (xdp_dbus_file_chooser_skeleton_get_type ())
#define XDP_DBUS_FILE_CHOOSER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_FILE_CHOOSER_SKELETON, XdpDbusFileChooserSkeleton))
#define XDP_DBUS_FILE_CHOOSER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_FILE_CHOOSER_SKELETON, XdpDbusFileChooserSkeletonClass))
#define XDP_DBUS_FILE_CHOOSER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_FILE_CHOOSER_SKELETON, XdpDbusFileChooserSkeletonClass))
#define XDP_DBUS_IS_FILE_CHOOSER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_FILE_CHOOSER_SKELETON))
#define XDP_DBUS_IS_FILE_CHOOSER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_FILE_CHOOSER_SKELETON))

typedef struct _XdpDbusFileChooserSkeleton XdpDbusFileChooserSkeleton;
typedef struct _XdpDbusFileChooserSkeletonClass XdpDbusFileChooserSkeletonClass;
typedef struct _XdpDbusFileChooserSkeletonPrivate XdpDbusFileChooserSkeletonPrivate;

struct _XdpDbusFileChooserSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusFileChooserSkeletonPrivate *priv;
};

struct _XdpDbusFileChooserSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_file_chooser_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusFileChooser *xdp_dbus_file_chooser_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.FileTransfer */

#define XDP_DBUS_TYPE_FILE_TRANSFER (xdp_dbus_file_transfer_get_type ())
#define XDP_DBUS_FILE_TRANSFER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_FILE_TRANSFER, XdpDbusFileTransfer))
#define XDP_DBUS_IS_FILE_TRANSFER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_FILE_TRANSFER))
#define XDP_DBUS_FILE_TRANSFER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_FILE_TRANSFER, XdpDbusFileTransferIface))

struct _XdpDbusFileTransfer;
typedef struct _XdpDbusFileTransfer XdpDbusFileTransfer;
typedef struct _XdpDbusFileTransferIface XdpDbusFileTransferIface;

struct _XdpDbusFileTransferIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_add_files) (
    XdpDbusFileTransfer *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_key,
    GVariant *arg_fds,
    GVariant *arg_options);

  gboolean (*handle_retrieve_files) (
    XdpDbusFileTransfer *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_key,
    GVariant *arg_options);

  gboolean (*handle_start_transfer) (
    XdpDbusFileTransfer *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_options);

  gboolean (*handle_stop_transfer) (
    XdpDbusFileTransfer *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_key);

  guint  (*get_version) (XdpDbusFileTransfer *object);

  void (*transfer_closed) (
    XdpDbusFileTransfer *object,
    const gchar *arg_key);

};

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

GType xdp_dbus_file_transfer_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_file_transfer_interface_info (void);
guint xdp_dbus_file_transfer_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_file_transfer_complete_start_transfer (
    XdpDbusFileTransfer *object,
    GDBusMethodInvocation *invocation,
    const gchar *key);

void xdp_dbus_file_transfer_complete_add_files (
    XdpDbusFileTransfer *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list);

void xdp_dbus_file_transfer_complete_retrieve_files (
    XdpDbusFileTransfer *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *files);

void xdp_dbus_file_transfer_complete_stop_transfer (
    XdpDbusFileTransfer *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void xdp_dbus_file_transfer_emit_transfer_closed (
    XdpDbusFileTransfer *object,
    const gchar *arg_key);



/* D-Bus method calls: */
void xdp_dbus_file_transfer_call_start_transfer (
    XdpDbusFileTransfer *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_file_transfer_call_start_transfer_finish (
    XdpDbusFileTransfer *proxy,
    gchar ** out_key,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_file_transfer_call_start_transfer_sync (
    XdpDbusFileTransfer *proxy,
    GVariant *arg_options,
    gchar ** out_key,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_file_transfer_call_add_files (
    XdpDbusFileTransfer *proxy,
    const gchar *arg_key,
    GVariant *arg_fds,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_file_transfer_call_add_files_finish (
    XdpDbusFileTransfer *proxy,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_file_transfer_call_add_files_sync (
    XdpDbusFileTransfer *proxy,
    const gchar *arg_key,
    GVariant *arg_fds,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_file_transfer_call_retrieve_files (
    XdpDbusFileTransfer *proxy,
    const gchar *arg_key,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_file_transfer_call_retrieve_files_finish (
    XdpDbusFileTransfer *proxy,
    gchar *** out_files,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_file_transfer_call_retrieve_files_sync (
    XdpDbusFileTransfer *proxy,
    const gchar *arg_key,
    GVariant *arg_options,
    gchar *** out_files,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_file_transfer_call_stop_transfer (
    XdpDbusFileTransfer *proxy,
    const gchar *arg_key,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_file_transfer_call_stop_transfer_finish (
    XdpDbusFileTransfer *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_file_transfer_call_stop_transfer_sync (
    XdpDbusFileTransfer *proxy,
    const gchar *arg_key,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_file_transfer_get_version (XdpDbusFileTransfer *object);
void xdp_dbus_file_transfer_set_version (XdpDbusFileTransfer *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_FILE_TRANSFER_PROXY (xdp_dbus_file_transfer_proxy_get_type ())
#define XDP_DBUS_FILE_TRANSFER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_FILE_TRANSFER_PROXY, XdpDbusFileTransferProxy))
#define XDP_DBUS_FILE_TRANSFER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_FILE_TRANSFER_PROXY, XdpDbusFileTransferProxyClass))
#define XDP_DBUS_FILE_TRANSFER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_FILE_TRANSFER_PROXY, XdpDbusFileTransferProxyClass))
#define XDP_DBUS_IS_FILE_TRANSFER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_FILE_TRANSFER_PROXY))
#define XDP_DBUS_IS_FILE_TRANSFER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_FILE_TRANSFER_PROXY))

typedef struct _XdpDbusFileTransferProxy XdpDbusFileTransferProxy;
typedef struct _XdpDbusFileTransferProxyClass XdpDbusFileTransferProxyClass;
typedef struct _XdpDbusFileTransferProxyPrivate XdpDbusFileTransferProxyPrivate;

struct _XdpDbusFileTransferProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusFileTransferProxyPrivate *priv;
};

struct _XdpDbusFileTransferProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_file_transfer_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_file_transfer_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusFileTransfer *xdp_dbus_file_transfer_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusFileTransfer *xdp_dbus_file_transfer_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_file_transfer_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusFileTransfer *xdp_dbus_file_transfer_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusFileTransfer *xdp_dbus_file_transfer_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_FILE_TRANSFER_SKELETON (xdp_dbus_file_transfer_skeleton_get_type ())
#define XDP_DBUS_FILE_TRANSFER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_FILE_TRANSFER_SKELETON, XdpDbusFileTransferSkeleton))
#define XDP_DBUS_FILE_TRANSFER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_FILE_TRANSFER_SKELETON, XdpDbusFileTransferSkeletonClass))
#define XDP_DBUS_FILE_TRANSFER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_FILE_TRANSFER_SKELETON, XdpDbusFileTransferSkeletonClass))
#define XDP_DBUS_IS_FILE_TRANSFER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_FILE_TRANSFER_SKELETON))
#define XDP_DBUS_IS_FILE_TRANSFER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_FILE_TRANSFER_SKELETON))

typedef struct _XdpDbusFileTransferSkeleton XdpDbusFileTransferSkeleton;
typedef struct _XdpDbusFileTransferSkeletonClass XdpDbusFileTransferSkeletonClass;
typedef struct _XdpDbusFileTransferSkeletonPrivate XdpDbusFileTransferSkeletonPrivate;

struct _XdpDbusFileTransferSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusFileTransferSkeletonPrivate *priv;
};

struct _XdpDbusFileTransferSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_file_transfer_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusFileTransfer *xdp_dbus_file_transfer_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.GameMode */

#define XDP_DBUS_TYPE_GAME_MODE (xdp_dbus_game_mode_get_type ())
#define XDP_DBUS_GAME_MODE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_GAME_MODE, XdpDbusGameMode))
#define XDP_DBUS_IS_GAME_MODE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_GAME_MODE))
#define XDP_DBUS_GAME_MODE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_GAME_MODE, XdpDbusGameModeIface))

struct _XdpDbusGameMode;
typedef struct _XdpDbusGameMode XdpDbusGameMode;
typedef struct _XdpDbusGameModeIface XdpDbusGameModeIface;

struct _XdpDbusGameModeIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_query_status) (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    gint arg_pid);

  gboolean (*handle_query_status_by_pid) (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    gint arg_target,
    gint arg_requester);

  gboolean (*handle_query_status_by_pidfd) (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *arg_target,
    GVariant *arg_requester);

  gboolean (*handle_register_game) (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    gint arg_pid);

  gboolean (*handle_register_game_by_pid) (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    gint arg_target,
    gint arg_requester);

  gboolean (*handle_register_game_by_pidfd) (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *arg_target,
    GVariant *arg_requester);

  gboolean (*handle_unregister_game) (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    gint arg_pid);

  gboolean (*handle_unregister_game_by_pid) (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    gint arg_target,
    gint arg_requester);

  gboolean (*handle_unregister_game_by_pidfd) (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *arg_target,
    GVariant *arg_requester);

  gboolean  (*get_active) (XdpDbusGameMode *object);

  guint  (*get_version) (XdpDbusGameMode *object);

};

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

GType xdp_dbus_game_mode_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_game_mode_interface_info (void);
guint xdp_dbus_game_mode_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_game_mode_complete_query_status (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    gint result);

void xdp_dbus_game_mode_complete_register_game (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    gint result);

void xdp_dbus_game_mode_complete_unregister_game (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    gint result);

void xdp_dbus_game_mode_complete_query_status_by_pid (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    gint result);

void xdp_dbus_game_mode_complete_register_game_by_pid (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    gint result);

void xdp_dbus_game_mode_complete_unregister_game_by_pid (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    gint result);

void xdp_dbus_game_mode_complete_query_status_by_pidfd (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    gint result);

void xdp_dbus_game_mode_complete_register_game_by_pidfd (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    gint result);

void xdp_dbus_game_mode_complete_unregister_game_by_pidfd (
    XdpDbusGameMode *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    gint result);



/* D-Bus method calls: */
void xdp_dbus_game_mode_call_query_status (
    XdpDbusGameMode *proxy,
    gint arg_pid,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_game_mode_call_query_status_finish (
    XdpDbusGameMode *proxy,
    gint* out_result,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_game_mode_call_query_status_sync (
    XdpDbusGameMode *proxy,
    gint arg_pid,
    gint* out_result,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_game_mode_call_register_game (
    XdpDbusGameMode *proxy,
    gint arg_pid,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_game_mode_call_register_game_finish (
    XdpDbusGameMode *proxy,
    gint* out_result,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_game_mode_call_register_game_sync (
    XdpDbusGameMode *proxy,
    gint arg_pid,
    gint* out_result,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_game_mode_call_unregister_game (
    XdpDbusGameMode *proxy,
    gint arg_pid,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_game_mode_call_unregister_game_finish (
    XdpDbusGameMode *proxy,
    gint* out_result,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_game_mode_call_unregister_game_sync (
    XdpDbusGameMode *proxy,
    gint arg_pid,
    gint* out_result,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_game_mode_call_query_status_by_pid (
    XdpDbusGameMode *proxy,
    gint arg_target,
    gint arg_requester,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_game_mode_call_query_status_by_pid_finish (
    XdpDbusGameMode *proxy,
    gint* out_result,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_game_mode_call_query_status_by_pid_sync (
    XdpDbusGameMode *proxy,
    gint arg_target,
    gint arg_requester,
    gint* out_result,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_game_mode_call_register_game_by_pid (
    XdpDbusGameMode *proxy,
    gint arg_target,
    gint arg_requester,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_game_mode_call_register_game_by_pid_finish (
    XdpDbusGameMode *proxy,
    gint* out_result,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_game_mode_call_register_game_by_pid_sync (
    XdpDbusGameMode *proxy,
    gint arg_target,
    gint arg_requester,
    gint* out_result,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_game_mode_call_unregister_game_by_pid (
    XdpDbusGameMode *proxy,
    gint arg_target,
    gint arg_requester,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_game_mode_call_unregister_game_by_pid_finish (
    XdpDbusGameMode *proxy,
    gint* out_result,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_game_mode_call_unregister_game_by_pid_sync (
    XdpDbusGameMode *proxy,
    gint arg_target,
    gint arg_requester,
    gint* out_result,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_game_mode_call_query_status_by_pidfd (
    XdpDbusGameMode *proxy,
    GVariant *arg_target,
    GVariant *arg_requester,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_game_mode_call_query_status_by_pidfd_finish (
    XdpDbusGameMode *proxy,
    gint* out_result,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_game_mode_call_query_status_by_pidfd_sync (
    XdpDbusGameMode *proxy,
    GVariant *arg_target,
    GVariant *arg_requester,
    GUnixFDList  *fd_list,
    gint* out_result,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_game_mode_call_register_game_by_pidfd (
    XdpDbusGameMode *proxy,
    GVariant *arg_target,
    GVariant *arg_requester,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_game_mode_call_register_game_by_pidfd_finish (
    XdpDbusGameMode *proxy,
    gint* out_result,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_game_mode_call_register_game_by_pidfd_sync (
    XdpDbusGameMode *proxy,
    GVariant *arg_target,
    GVariant *arg_requester,
    GUnixFDList  *fd_list,
    gint* out_result,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_game_mode_call_unregister_game_by_pidfd (
    XdpDbusGameMode *proxy,
    GVariant *arg_target,
    GVariant *arg_requester,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_game_mode_call_unregister_game_by_pidfd_finish (
    XdpDbusGameMode *proxy,
    gint* out_result,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_game_mode_call_unregister_game_by_pidfd_sync (
    XdpDbusGameMode *proxy,
    GVariant *arg_target,
    GVariant *arg_requester,
    GUnixFDList  *fd_list,
    gint* out_result,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
gboolean xdp_dbus_game_mode_get_active (XdpDbusGameMode *object);
void xdp_dbus_game_mode_set_active (XdpDbusGameMode *object, gboolean value);

guint xdp_dbus_game_mode_get_version (XdpDbusGameMode *object);
void xdp_dbus_game_mode_set_version (XdpDbusGameMode *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_GAME_MODE_PROXY (xdp_dbus_game_mode_proxy_get_type ())
#define XDP_DBUS_GAME_MODE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_GAME_MODE_PROXY, XdpDbusGameModeProxy))
#define XDP_DBUS_GAME_MODE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_GAME_MODE_PROXY, XdpDbusGameModeProxyClass))
#define XDP_DBUS_GAME_MODE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_GAME_MODE_PROXY, XdpDbusGameModeProxyClass))
#define XDP_DBUS_IS_GAME_MODE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_GAME_MODE_PROXY))
#define XDP_DBUS_IS_GAME_MODE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_GAME_MODE_PROXY))

typedef struct _XdpDbusGameModeProxy XdpDbusGameModeProxy;
typedef struct _XdpDbusGameModeProxyClass XdpDbusGameModeProxyClass;
typedef struct _XdpDbusGameModeProxyPrivate XdpDbusGameModeProxyPrivate;

struct _XdpDbusGameModeProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusGameModeProxyPrivate *priv;
};

struct _XdpDbusGameModeProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_game_mode_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_game_mode_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusGameMode *xdp_dbus_game_mode_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusGameMode *xdp_dbus_game_mode_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_game_mode_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusGameMode *xdp_dbus_game_mode_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusGameMode *xdp_dbus_game_mode_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_GAME_MODE_SKELETON (xdp_dbus_game_mode_skeleton_get_type ())
#define XDP_DBUS_GAME_MODE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_GAME_MODE_SKELETON, XdpDbusGameModeSkeleton))
#define XDP_DBUS_GAME_MODE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_GAME_MODE_SKELETON, XdpDbusGameModeSkeletonClass))
#define XDP_DBUS_GAME_MODE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_GAME_MODE_SKELETON, XdpDbusGameModeSkeletonClass))
#define XDP_DBUS_IS_GAME_MODE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_GAME_MODE_SKELETON))
#define XDP_DBUS_IS_GAME_MODE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_GAME_MODE_SKELETON))

typedef struct _XdpDbusGameModeSkeleton XdpDbusGameModeSkeleton;
typedef struct _XdpDbusGameModeSkeletonClass XdpDbusGameModeSkeletonClass;
typedef struct _XdpDbusGameModeSkeletonPrivate XdpDbusGameModeSkeletonPrivate;

struct _XdpDbusGameModeSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusGameModeSkeletonPrivate *priv;
};

struct _XdpDbusGameModeSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_game_mode_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusGameMode *xdp_dbus_game_mode_skeleton_new (void);


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

#define XDP_DBUS_TYPE_GLOBAL_SHORTCUTS (xdp_dbus_global_shortcuts_get_type ())
#define XDP_DBUS_GLOBAL_SHORTCUTS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_GLOBAL_SHORTCUTS, XdpDbusGlobalShortcuts))
#define XDP_DBUS_IS_GLOBAL_SHORTCUTS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_GLOBAL_SHORTCUTS))
#define XDP_DBUS_GLOBAL_SHORTCUTS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_GLOBAL_SHORTCUTS, XdpDbusGlobalShortcutsIface))

struct _XdpDbusGlobalShortcuts;
typedef struct _XdpDbusGlobalShortcuts XdpDbusGlobalShortcuts;
typedef struct _XdpDbusGlobalShortcutsIface XdpDbusGlobalShortcutsIface;

struct _XdpDbusGlobalShortcutsIface
{
  GTypeInterface parent_iface;



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

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

  gboolean (*handle_create_session) (
    XdpDbusGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_options);

  gboolean (*handle_list_shortcuts) (
    XdpDbusGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options);

  guint  (*get_version) (XdpDbusGlobalShortcuts *object);

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

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

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

};

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

GType xdp_dbus_global_shortcuts_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_global_shortcuts_interface_info (void);
guint xdp_dbus_global_shortcuts_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_global_shortcuts_complete_create_session (
    XdpDbusGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_global_shortcuts_complete_bind_shortcuts (
    XdpDbusGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    const gchar *request_handle);

void xdp_dbus_global_shortcuts_complete_list_shortcuts (
    XdpDbusGlobalShortcuts *object,
    GDBusMethodInvocation *invocation,
    const gchar *request_handle);

void xdp_dbus_global_shortcuts_complete_configure_shortcuts (
    XdpDbusGlobalShortcuts *object,
    GDBusMethodInvocation *invocation);



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

void xdp_dbus_global_shortcuts_emit_deactivated (
    XdpDbusGlobalShortcuts *object,
    const gchar *arg_session_handle,
    const gchar *arg_shortcut_id,
    guint64 arg_timestamp,
    GVariant *arg_options);

void xdp_dbus_global_shortcuts_emit_shortcuts_changed (
    XdpDbusGlobalShortcuts *object,
    const gchar *arg_session_handle,
    GVariant *arg_shortcuts);



/* D-Bus method calls: */
void xdp_dbus_global_shortcuts_call_create_session (
    XdpDbusGlobalShortcuts *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_global_shortcuts_call_create_session_finish (
    XdpDbusGlobalShortcuts *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_global_shortcuts_call_create_session_sync (
    XdpDbusGlobalShortcuts *proxy,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_global_shortcuts_call_bind_shortcuts_finish (
    XdpDbusGlobalShortcuts *proxy,
    gchar ** out_request_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_global_shortcuts_call_bind_shortcuts_sync (
    XdpDbusGlobalShortcuts *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_shortcuts,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    gchar ** out_request_handle,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_global_shortcuts_call_list_shortcuts_finish (
    XdpDbusGlobalShortcuts *proxy,
    gchar ** out_request_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_global_shortcuts_call_list_shortcuts_sync (
    XdpDbusGlobalShortcuts *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gchar ** out_request_handle,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_global_shortcuts_call_configure_shortcuts_finish (
    XdpDbusGlobalShortcuts *proxy,
    GAsyncResult *res,
    GError **error);

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



/* D-Bus property accessors: */
guint xdp_dbus_global_shortcuts_get_version (XdpDbusGlobalShortcuts *object);
void xdp_dbus_global_shortcuts_set_version (XdpDbusGlobalShortcuts *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_GLOBAL_SHORTCUTS_PROXY (xdp_dbus_global_shortcuts_proxy_get_type ())
#define XDP_DBUS_GLOBAL_SHORTCUTS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_GLOBAL_SHORTCUTS_PROXY, XdpDbusGlobalShortcutsProxy))
#define XDP_DBUS_GLOBAL_SHORTCUTS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_GLOBAL_SHORTCUTS_PROXY, XdpDbusGlobalShortcutsProxyClass))
#define XDP_DBUS_GLOBAL_SHORTCUTS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_GLOBAL_SHORTCUTS_PROXY, XdpDbusGlobalShortcutsProxyClass))
#define XDP_DBUS_IS_GLOBAL_SHORTCUTS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_GLOBAL_SHORTCUTS_PROXY))
#define XDP_DBUS_IS_GLOBAL_SHORTCUTS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_GLOBAL_SHORTCUTS_PROXY))

typedef struct _XdpDbusGlobalShortcutsProxy XdpDbusGlobalShortcutsProxy;
typedef struct _XdpDbusGlobalShortcutsProxyClass XdpDbusGlobalShortcutsProxyClass;
typedef struct _XdpDbusGlobalShortcutsProxyPrivate XdpDbusGlobalShortcutsProxyPrivate;

struct _XdpDbusGlobalShortcutsProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusGlobalShortcutsProxyPrivate *priv;
};

struct _XdpDbusGlobalShortcutsProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_global_shortcuts_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_global_shortcuts_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusGlobalShortcuts *xdp_dbus_global_shortcuts_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusGlobalShortcuts *xdp_dbus_global_shortcuts_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_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);
XdpDbusGlobalShortcuts *xdp_dbus_global_shortcuts_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusGlobalShortcuts *xdp_dbus_global_shortcuts_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_GLOBAL_SHORTCUTS_SKELETON (xdp_dbus_global_shortcuts_skeleton_get_type ())
#define XDP_DBUS_GLOBAL_SHORTCUTS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_GLOBAL_SHORTCUTS_SKELETON, XdpDbusGlobalShortcutsSkeleton))
#define XDP_DBUS_GLOBAL_SHORTCUTS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_GLOBAL_SHORTCUTS_SKELETON, XdpDbusGlobalShortcutsSkeletonClass))
#define XDP_DBUS_GLOBAL_SHORTCUTS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_GLOBAL_SHORTCUTS_SKELETON, XdpDbusGlobalShortcutsSkeletonClass))
#define XDP_DBUS_IS_GLOBAL_SHORTCUTS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_GLOBAL_SHORTCUTS_SKELETON))
#define XDP_DBUS_IS_GLOBAL_SHORTCUTS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_GLOBAL_SHORTCUTS_SKELETON))

typedef struct _XdpDbusGlobalShortcutsSkeleton XdpDbusGlobalShortcutsSkeleton;
typedef struct _XdpDbusGlobalShortcutsSkeletonClass XdpDbusGlobalShortcutsSkeletonClass;
typedef struct _XdpDbusGlobalShortcutsSkeletonPrivate XdpDbusGlobalShortcutsSkeletonPrivate;

struct _XdpDbusGlobalShortcutsSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusGlobalShortcutsSkeletonPrivate *priv;
};

struct _XdpDbusGlobalShortcutsSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_global_shortcuts_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusGlobalShortcuts *xdp_dbus_global_shortcuts_skeleton_new (void);


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

#define XDP_DBUS_TYPE_INHIBIT (xdp_dbus_inhibit_get_type ())
#define XDP_DBUS_INHIBIT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_INHIBIT, XdpDbusInhibit))
#define XDP_DBUS_IS_INHIBIT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_INHIBIT))
#define XDP_DBUS_INHIBIT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_INHIBIT, XdpDbusInhibitIface))

struct _XdpDbusInhibit;
typedef struct _XdpDbusInhibit XdpDbusInhibit;
typedef struct _XdpDbusInhibitIface XdpDbusInhibitIface;

struct _XdpDbusInhibitIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_create_monitor) (
    XdpDbusInhibit *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_window,
    GVariant *arg_options);

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

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

  guint  (*get_version) (XdpDbusInhibit *object);

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

};

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

GType xdp_dbus_inhibit_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_inhibit_interface_info (void);
guint xdp_dbus_inhibit_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_inhibit_complete_inhibit (
    XdpDbusInhibit *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_inhibit_complete_create_monitor (
    XdpDbusInhibit *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_inhibit_complete_query_end_response (
    XdpDbusInhibit *object,
    GDBusMethodInvocation *invocation);



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



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

gboolean xdp_dbus_inhibit_call_inhibit_finish (
    XdpDbusInhibit *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_inhibit_call_inhibit_sync (
    XdpDbusInhibit *proxy,
    const gchar *arg_window,
    guint arg_flags,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_inhibit_call_create_monitor (
    XdpDbusInhibit *proxy,
    const gchar *arg_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_inhibit_call_create_monitor_finish (
    XdpDbusInhibit *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_inhibit_call_create_monitor_sync (
    XdpDbusInhibit *proxy,
    const gchar *arg_window,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_inhibit_call_query_end_response_finish (
    XdpDbusInhibit *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_inhibit_call_query_end_response_sync (
    XdpDbusInhibit *proxy,
    const gchar *arg_session_handle,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_inhibit_get_version (XdpDbusInhibit *object);
void xdp_dbus_inhibit_set_version (XdpDbusInhibit *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_INHIBIT_PROXY (xdp_dbus_inhibit_proxy_get_type ())
#define XDP_DBUS_INHIBIT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_INHIBIT_PROXY, XdpDbusInhibitProxy))
#define XDP_DBUS_INHIBIT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_INHIBIT_PROXY, XdpDbusInhibitProxyClass))
#define XDP_DBUS_INHIBIT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_INHIBIT_PROXY, XdpDbusInhibitProxyClass))
#define XDP_DBUS_IS_INHIBIT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_INHIBIT_PROXY))
#define XDP_DBUS_IS_INHIBIT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_INHIBIT_PROXY))

typedef struct _XdpDbusInhibitProxy XdpDbusInhibitProxy;
typedef struct _XdpDbusInhibitProxyClass XdpDbusInhibitProxyClass;
typedef struct _XdpDbusInhibitProxyPrivate XdpDbusInhibitProxyPrivate;

struct _XdpDbusInhibitProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusInhibitProxyPrivate *priv;
};

struct _XdpDbusInhibitProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_inhibit_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_inhibit_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusInhibit *xdp_dbus_inhibit_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusInhibit *xdp_dbus_inhibit_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_inhibit_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusInhibit *xdp_dbus_inhibit_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusInhibit *xdp_dbus_inhibit_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_INHIBIT_SKELETON (xdp_dbus_inhibit_skeleton_get_type ())
#define XDP_DBUS_INHIBIT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_INHIBIT_SKELETON, XdpDbusInhibitSkeleton))
#define XDP_DBUS_INHIBIT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_INHIBIT_SKELETON, XdpDbusInhibitSkeletonClass))
#define XDP_DBUS_INHIBIT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_INHIBIT_SKELETON, XdpDbusInhibitSkeletonClass))
#define XDP_DBUS_IS_INHIBIT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_INHIBIT_SKELETON))
#define XDP_DBUS_IS_INHIBIT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_INHIBIT_SKELETON))

typedef struct _XdpDbusInhibitSkeleton XdpDbusInhibitSkeleton;
typedef struct _XdpDbusInhibitSkeletonClass XdpDbusInhibitSkeletonClass;
typedef struct _XdpDbusInhibitSkeletonPrivate XdpDbusInhibitSkeletonPrivate;

struct _XdpDbusInhibitSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusInhibitSkeletonPrivate *priv;
};

struct _XdpDbusInhibitSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_inhibit_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusInhibit *xdp_dbus_inhibit_skeleton_new (void);


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

#define XDP_DBUS_TYPE_INPUT_CAPTURE (xdp_dbus_input_capture_get_type ())
#define XDP_DBUS_INPUT_CAPTURE(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_INPUT_CAPTURE, XdpDbusInputCapture))
#define XDP_DBUS_IS_INPUT_CAPTURE(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_INPUT_CAPTURE))
#define XDP_DBUS_INPUT_CAPTURE_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_INPUT_CAPTURE, XdpDbusInputCaptureIface))

struct _XdpDbusInputCapture;
typedef struct _XdpDbusInputCapture XdpDbusInputCapture;
typedef struct _XdpDbusInputCaptureIface XdpDbusInputCaptureIface;

struct _XdpDbusInputCaptureIface
{
  GTypeInterface parent_iface;



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

  gboolean (*handle_create_session) (
    XdpDbusInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  gboolean (*handle_create_session2) (
    XdpDbusInputCapture *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_options);

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

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

  gboolean (*handle_get_zones) (
    XdpDbusInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options);

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

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

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

  guint  (*get_supported_capabilities) (XdpDbusInputCapture *object);

  guint  (*get_version) (XdpDbusInputCapture *object);

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

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

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

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

};

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

GType xdp_dbus_input_capture_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_input_capture_interface_info (void);
guint xdp_dbus_input_capture_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
G_GNUC_DEPRECATED void xdp_dbus_input_capture_complete_create_session (
    XdpDbusInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_input_capture_complete_create_session2 (
    XdpDbusInputCapture *object,
    GDBusMethodInvocation *invocation,
    GVariant *results);

void xdp_dbus_input_capture_complete_start (
    XdpDbusInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_input_capture_complete_get_zones (
    XdpDbusInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_input_capture_complete_set_pointer_barriers (
    XdpDbusInputCapture *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_input_capture_complete_enable (
    XdpDbusInputCapture *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_input_capture_complete_disable (
    XdpDbusInputCapture *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_input_capture_complete_release (
    XdpDbusInputCapture *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_input_capture_complete_connect_to_eis (
    XdpDbusInputCapture *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);



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

void xdp_dbus_input_capture_emit_activated (
    XdpDbusInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);

void xdp_dbus_input_capture_emit_deactivated (
    XdpDbusInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);

void xdp_dbus_input_capture_emit_zones_changed (
    XdpDbusInputCapture *object,
    const gchar *arg_session_handle,
    GVariant *arg_options);



/* D-Bus method calls: */
G_GNUC_DEPRECATED void xdp_dbus_input_capture_call_create_session (
    XdpDbusInputCapture *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

G_GNUC_DEPRECATED gboolean xdp_dbus_input_capture_call_create_session_finish (
    XdpDbusInputCapture *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

G_GNUC_DEPRECATED gboolean xdp_dbus_input_capture_call_create_session_sync (
    XdpDbusInputCapture *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_input_capture_call_create_session2 (
    XdpDbusInputCapture *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_input_capture_call_create_session2_finish (
    XdpDbusInputCapture *proxy,
    GVariant ** out_results,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_input_capture_call_create_session2_sync (
    XdpDbusInputCapture *proxy,
    GVariant *arg_options,
    GVariant ** out_results,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_input_capture_call_start_finish (
    XdpDbusInputCapture *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_input_capture_call_start_sync (
    XdpDbusInputCapture *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_input_capture_call_get_zones_finish (
    XdpDbusInputCapture *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_input_capture_call_get_zones_sync (
    XdpDbusInputCapture *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_input_capture_call_set_pointer_barriers (
    XdpDbusInputCapture *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    GVariant *arg_barriers,
    guint arg_zone_set,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_input_capture_call_set_pointer_barriers_finish (
    XdpDbusInputCapture *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_input_capture_call_set_pointer_barriers_sync (
    XdpDbusInputCapture *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    GVariant *arg_barriers,
    guint arg_zone_set,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_input_capture_call_enable_finish (
    XdpDbusInputCapture *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_input_capture_call_disable_finish (
    XdpDbusInputCapture *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_input_capture_call_release_finish (
    XdpDbusInputCapture *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_input_capture_call_connect_to_eis_finish (
    XdpDbusInputCapture *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

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



/* D-Bus property accessors: */
guint xdp_dbus_input_capture_get_supported_capabilities (XdpDbusInputCapture *object);
void xdp_dbus_input_capture_set_supported_capabilities (XdpDbusInputCapture *object, guint value);

guint xdp_dbus_input_capture_get_version (XdpDbusInputCapture *object);
void xdp_dbus_input_capture_set_version (XdpDbusInputCapture *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_INPUT_CAPTURE_PROXY (xdp_dbus_input_capture_proxy_get_type ())
#define XDP_DBUS_INPUT_CAPTURE_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_INPUT_CAPTURE_PROXY, XdpDbusInputCaptureProxy))
#define XDP_DBUS_INPUT_CAPTURE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_INPUT_CAPTURE_PROXY, XdpDbusInputCaptureProxyClass))
#define XDP_DBUS_INPUT_CAPTURE_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_INPUT_CAPTURE_PROXY, XdpDbusInputCaptureProxyClass))
#define XDP_DBUS_IS_INPUT_CAPTURE_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_INPUT_CAPTURE_PROXY))
#define XDP_DBUS_IS_INPUT_CAPTURE_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_INPUT_CAPTURE_PROXY))

typedef struct _XdpDbusInputCaptureProxy XdpDbusInputCaptureProxy;
typedef struct _XdpDbusInputCaptureProxyClass XdpDbusInputCaptureProxyClass;
typedef struct _XdpDbusInputCaptureProxyPrivate XdpDbusInputCaptureProxyPrivate;

struct _XdpDbusInputCaptureProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusInputCaptureProxyPrivate *priv;
};

struct _XdpDbusInputCaptureProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_input_capture_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_input_capture_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusInputCapture *xdp_dbus_input_capture_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusInputCapture *xdp_dbus_input_capture_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_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);
XdpDbusInputCapture *xdp_dbus_input_capture_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusInputCapture *xdp_dbus_input_capture_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_INPUT_CAPTURE_SKELETON (xdp_dbus_input_capture_skeleton_get_type ())
#define XDP_DBUS_INPUT_CAPTURE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_INPUT_CAPTURE_SKELETON, XdpDbusInputCaptureSkeleton))
#define XDP_DBUS_INPUT_CAPTURE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_INPUT_CAPTURE_SKELETON, XdpDbusInputCaptureSkeletonClass))
#define XDP_DBUS_INPUT_CAPTURE_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_INPUT_CAPTURE_SKELETON, XdpDbusInputCaptureSkeletonClass))
#define XDP_DBUS_IS_INPUT_CAPTURE_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_INPUT_CAPTURE_SKELETON))
#define XDP_DBUS_IS_INPUT_CAPTURE_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_INPUT_CAPTURE_SKELETON))

typedef struct _XdpDbusInputCaptureSkeleton XdpDbusInputCaptureSkeleton;
typedef struct _XdpDbusInputCaptureSkeletonClass XdpDbusInputCaptureSkeletonClass;
typedef struct _XdpDbusInputCaptureSkeletonPrivate XdpDbusInputCaptureSkeletonPrivate;

struct _XdpDbusInputCaptureSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusInputCaptureSkeletonPrivate *priv;
};

struct _XdpDbusInputCaptureSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_input_capture_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusInputCapture *xdp_dbus_input_capture_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.Location */

#define XDP_DBUS_TYPE_LOCATION (xdp_dbus_location_get_type ())
#define XDP_DBUS_LOCATION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_LOCATION, XdpDbusLocation))
#define XDP_DBUS_IS_LOCATION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_LOCATION))
#define XDP_DBUS_LOCATION_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_LOCATION, XdpDbusLocationIface))

struct _XdpDbusLocation;
typedef struct _XdpDbusLocation XdpDbusLocation;
typedef struct _XdpDbusLocationIface XdpDbusLocationIface;

struct _XdpDbusLocationIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_create_session) (
    XdpDbusLocation *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_options);

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

  guint  (*get_version) (XdpDbusLocation *object);

  void (*location_updated) (
    XdpDbusLocation *object,
    const gchar *arg_session_handle,
    GVariant *arg_location);

};

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

GType xdp_dbus_location_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_location_interface_info (void);
guint xdp_dbus_location_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_location_complete_create_session (
    XdpDbusLocation *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_location_complete_start (
    XdpDbusLocation *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);



/* D-Bus signal emissions functions: */
void xdp_dbus_location_emit_location_updated (
    XdpDbusLocation *object,
    const gchar *arg_session_handle,
    GVariant *arg_location);



/* D-Bus method calls: */
void xdp_dbus_location_call_create_session (
    XdpDbusLocation *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_location_call_create_session_finish (
    XdpDbusLocation *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_location_call_create_session_sync (
    XdpDbusLocation *proxy,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_location_call_start_finish (
    XdpDbusLocation *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_location_call_start_sync (
    XdpDbusLocation *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_location_get_version (XdpDbusLocation *object);
void xdp_dbus_location_set_version (XdpDbusLocation *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_LOCATION_PROXY (xdp_dbus_location_proxy_get_type ())
#define XDP_DBUS_LOCATION_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_LOCATION_PROXY, XdpDbusLocationProxy))
#define XDP_DBUS_LOCATION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_LOCATION_PROXY, XdpDbusLocationProxyClass))
#define XDP_DBUS_LOCATION_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_LOCATION_PROXY, XdpDbusLocationProxyClass))
#define XDP_DBUS_IS_LOCATION_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_LOCATION_PROXY))
#define XDP_DBUS_IS_LOCATION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_LOCATION_PROXY))

typedef struct _XdpDbusLocationProxy XdpDbusLocationProxy;
typedef struct _XdpDbusLocationProxyClass XdpDbusLocationProxyClass;
typedef struct _XdpDbusLocationProxyPrivate XdpDbusLocationProxyPrivate;

struct _XdpDbusLocationProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusLocationProxyPrivate *priv;
};

struct _XdpDbusLocationProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_location_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_location_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusLocation *xdp_dbus_location_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusLocation *xdp_dbus_location_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_location_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusLocation *xdp_dbus_location_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusLocation *xdp_dbus_location_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_LOCATION_SKELETON (xdp_dbus_location_skeleton_get_type ())
#define XDP_DBUS_LOCATION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_LOCATION_SKELETON, XdpDbusLocationSkeleton))
#define XDP_DBUS_LOCATION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_LOCATION_SKELETON, XdpDbusLocationSkeletonClass))
#define XDP_DBUS_LOCATION_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_LOCATION_SKELETON, XdpDbusLocationSkeletonClass))
#define XDP_DBUS_IS_LOCATION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_LOCATION_SKELETON))
#define XDP_DBUS_IS_LOCATION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_LOCATION_SKELETON))

typedef struct _XdpDbusLocationSkeleton XdpDbusLocationSkeleton;
typedef struct _XdpDbusLocationSkeletonClass XdpDbusLocationSkeletonClass;
typedef struct _XdpDbusLocationSkeletonPrivate XdpDbusLocationSkeletonPrivate;

struct _XdpDbusLocationSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusLocationSkeletonPrivate *priv;
};

struct _XdpDbusLocationSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_location_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusLocation *xdp_dbus_location_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.MemoryMonitor */

#define XDP_DBUS_TYPE_MEMORY_MONITOR (xdp_dbus_memory_monitor_get_type ())
#define XDP_DBUS_MEMORY_MONITOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_MEMORY_MONITOR, XdpDbusMemoryMonitor))
#define XDP_DBUS_IS_MEMORY_MONITOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_MEMORY_MONITOR))
#define XDP_DBUS_MEMORY_MONITOR_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_MEMORY_MONITOR, XdpDbusMemoryMonitorIface))

struct _XdpDbusMemoryMonitor;
typedef struct _XdpDbusMemoryMonitor XdpDbusMemoryMonitor;
typedef struct _XdpDbusMemoryMonitorIface XdpDbusMemoryMonitorIface;

struct _XdpDbusMemoryMonitorIface
{
  GTypeInterface parent_iface;


  guint  (*get_version) (XdpDbusMemoryMonitor *object);

  void (*low_memory_warning) (
    XdpDbusMemoryMonitor *object,
    guchar arg_level);

};

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

GType xdp_dbus_memory_monitor_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_memory_monitor_interface_info (void);
guint xdp_dbus_memory_monitor_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus signal emissions functions: */
void xdp_dbus_memory_monitor_emit_low_memory_warning (
    XdpDbusMemoryMonitor *object,
    guchar arg_level);



/* D-Bus property accessors: */
guint xdp_dbus_memory_monitor_get_version (XdpDbusMemoryMonitor *object);
void xdp_dbus_memory_monitor_set_version (XdpDbusMemoryMonitor *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_MEMORY_MONITOR_PROXY (xdp_dbus_memory_monitor_proxy_get_type ())
#define XDP_DBUS_MEMORY_MONITOR_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_MEMORY_MONITOR_PROXY, XdpDbusMemoryMonitorProxy))
#define XDP_DBUS_MEMORY_MONITOR_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_MEMORY_MONITOR_PROXY, XdpDbusMemoryMonitorProxyClass))
#define XDP_DBUS_MEMORY_MONITOR_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_MEMORY_MONITOR_PROXY, XdpDbusMemoryMonitorProxyClass))
#define XDP_DBUS_IS_MEMORY_MONITOR_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_MEMORY_MONITOR_PROXY))
#define XDP_DBUS_IS_MEMORY_MONITOR_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_MEMORY_MONITOR_PROXY))

typedef struct _XdpDbusMemoryMonitorProxy XdpDbusMemoryMonitorProxy;
typedef struct _XdpDbusMemoryMonitorProxyClass XdpDbusMemoryMonitorProxyClass;
typedef struct _XdpDbusMemoryMonitorProxyPrivate XdpDbusMemoryMonitorProxyPrivate;

struct _XdpDbusMemoryMonitorProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusMemoryMonitorProxyPrivate *priv;
};

struct _XdpDbusMemoryMonitorProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_memory_monitor_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_memory_monitor_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusMemoryMonitor *xdp_dbus_memory_monitor_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusMemoryMonitor *xdp_dbus_memory_monitor_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_memory_monitor_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusMemoryMonitor *xdp_dbus_memory_monitor_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusMemoryMonitor *xdp_dbus_memory_monitor_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_MEMORY_MONITOR_SKELETON (xdp_dbus_memory_monitor_skeleton_get_type ())
#define XDP_DBUS_MEMORY_MONITOR_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_MEMORY_MONITOR_SKELETON, XdpDbusMemoryMonitorSkeleton))
#define XDP_DBUS_MEMORY_MONITOR_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_MEMORY_MONITOR_SKELETON, XdpDbusMemoryMonitorSkeletonClass))
#define XDP_DBUS_MEMORY_MONITOR_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_MEMORY_MONITOR_SKELETON, XdpDbusMemoryMonitorSkeletonClass))
#define XDP_DBUS_IS_MEMORY_MONITOR_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_MEMORY_MONITOR_SKELETON))
#define XDP_DBUS_IS_MEMORY_MONITOR_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_MEMORY_MONITOR_SKELETON))

typedef struct _XdpDbusMemoryMonitorSkeleton XdpDbusMemoryMonitorSkeleton;
typedef struct _XdpDbusMemoryMonitorSkeletonClass XdpDbusMemoryMonitorSkeletonClass;
typedef struct _XdpDbusMemoryMonitorSkeletonPrivate XdpDbusMemoryMonitorSkeletonPrivate;

struct _XdpDbusMemoryMonitorSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusMemoryMonitorSkeletonPrivate *priv;
};

struct _XdpDbusMemoryMonitorSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_memory_monitor_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusMemoryMonitor *xdp_dbus_memory_monitor_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.NetworkMonitor */

#define XDP_DBUS_TYPE_NETWORK_MONITOR (xdp_dbus_network_monitor_get_type ())
#define XDP_DBUS_NETWORK_MONITOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_NETWORK_MONITOR, XdpDbusNetworkMonitor))
#define XDP_DBUS_IS_NETWORK_MONITOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_NETWORK_MONITOR))
#define XDP_DBUS_NETWORK_MONITOR_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_NETWORK_MONITOR, XdpDbusNetworkMonitorIface))

struct _XdpDbusNetworkMonitor;
typedef struct _XdpDbusNetworkMonitor XdpDbusNetworkMonitor;
typedef struct _XdpDbusNetworkMonitorIface XdpDbusNetworkMonitorIface;

struct _XdpDbusNetworkMonitorIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_can_reach) (
    XdpDbusNetworkMonitor *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_hostname,
    guint arg_port);

  gboolean (*handle_get_available) (
    XdpDbusNetworkMonitor *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_get_connectivity) (
    XdpDbusNetworkMonitor *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_get_metered) (
    XdpDbusNetworkMonitor *object,
    GDBusMethodInvocation *invocation);

  gboolean (*handle_get_status) (
    XdpDbusNetworkMonitor *object,
    GDBusMethodInvocation *invocation);

  guint  (*get_version) (XdpDbusNetworkMonitor *object);

  void (*changed) (
    XdpDbusNetworkMonitor *object);

};

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

GType xdp_dbus_network_monitor_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_network_monitor_interface_info (void);
guint xdp_dbus_network_monitor_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_network_monitor_complete_get_available (
    XdpDbusNetworkMonitor *object,
    GDBusMethodInvocation *invocation,
    gboolean available);

void xdp_dbus_network_monitor_complete_get_metered (
    XdpDbusNetworkMonitor *object,
    GDBusMethodInvocation *invocation,
    gboolean metered);

void xdp_dbus_network_monitor_complete_get_connectivity (
    XdpDbusNetworkMonitor *object,
    GDBusMethodInvocation *invocation,
    guint connectivity);

void xdp_dbus_network_monitor_complete_get_status (
    XdpDbusNetworkMonitor *object,
    GDBusMethodInvocation *invocation,
    GVariant *status);

void xdp_dbus_network_monitor_complete_can_reach (
    XdpDbusNetworkMonitor *object,
    GDBusMethodInvocation *invocation,
    gboolean reachable);



/* D-Bus signal emissions functions: */
void xdp_dbus_network_monitor_emit_changed (
    XdpDbusNetworkMonitor *object);



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

gboolean xdp_dbus_network_monitor_call_get_available_finish (
    XdpDbusNetworkMonitor *proxy,
    gboolean* out_available,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_network_monitor_call_get_available_sync (
    XdpDbusNetworkMonitor *proxy,
    gboolean* out_available,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_network_monitor_call_get_metered (
    XdpDbusNetworkMonitor *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_network_monitor_call_get_metered_finish (
    XdpDbusNetworkMonitor *proxy,
    gboolean* out_metered,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_network_monitor_call_get_metered_sync (
    XdpDbusNetworkMonitor *proxy,
    gboolean* out_metered,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_network_monitor_call_get_connectivity (
    XdpDbusNetworkMonitor *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_network_monitor_call_get_connectivity_finish (
    XdpDbusNetworkMonitor *proxy,
    guint* out_connectivity,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_network_monitor_call_get_connectivity_sync (
    XdpDbusNetworkMonitor *proxy,
    guint* out_connectivity,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_network_monitor_call_get_status (
    XdpDbusNetworkMonitor *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_network_monitor_call_get_status_finish (
    XdpDbusNetworkMonitor *proxy,
    GVariant ** out_status,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_network_monitor_call_get_status_sync (
    XdpDbusNetworkMonitor *proxy,
    GVariant ** out_status,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_network_monitor_call_can_reach (
    XdpDbusNetworkMonitor *proxy,
    const gchar *arg_hostname,
    guint arg_port,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_network_monitor_call_can_reach_finish (
    XdpDbusNetworkMonitor *proxy,
    gboolean* out_reachable,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_network_monitor_call_can_reach_sync (
    XdpDbusNetworkMonitor *proxy,
    const gchar *arg_hostname,
    guint arg_port,
    gboolean* out_reachable,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_network_monitor_get_version (XdpDbusNetworkMonitor *object);
void xdp_dbus_network_monitor_set_version (XdpDbusNetworkMonitor *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_NETWORK_MONITOR_PROXY (xdp_dbus_network_monitor_proxy_get_type ())
#define XDP_DBUS_NETWORK_MONITOR_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_NETWORK_MONITOR_PROXY, XdpDbusNetworkMonitorProxy))
#define XDP_DBUS_NETWORK_MONITOR_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_NETWORK_MONITOR_PROXY, XdpDbusNetworkMonitorProxyClass))
#define XDP_DBUS_NETWORK_MONITOR_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_NETWORK_MONITOR_PROXY, XdpDbusNetworkMonitorProxyClass))
#define XDP_DBUS_IS_NETWORK_MONITOR_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_NETWORK_MONITOR_PROXY))
#define XDP_DBUS_IS_NETWORK_MONITOR_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_NETWORK_MONITOR_PROXY))

typedef struct _XdpDbusNetworkMonitorProxy XdpDbusNetworkMonitorProxy;
typedef struct _XdpDbusNetworkMonitorProxyClass XdpDbusNetworkMonitorProxyClass;
typedef struct _XdpDbusNetworkMonitorProxyPrivate XdpDbusNetworkMonitorProxyPrivate;

struct _XdpDbusNetworkMonitorProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusNetworkMonitorProxyPrivate *priv;
};

struct _XdpDbusNetworkMonitorProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_network_monitor_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_network_monitor_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusNetworkMonitor *xdp_dbus_network_monitor_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusNetworkMonitor *xdp_dbus_network_monitor_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_network_monitor_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusNetworkMonitor *xdp_dbus_network_monitor_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusNetworkMonitor *xdp_dbus_network_monitor_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_NETWORK_MONITOR_SKELETON (xdp_dbus_network_monitor_skeleton_get_type ())
#define XDP_DBUS_NETWORK_MONITOR_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_NETWORK_MONITOR_SKELETON, XdpDbusNetworkMonitorSkeleton))
#define XDP_DBUS_NETWORK_MONITOR_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_NETWORK_MONITOR_SKELETON, XdpDbusNetworkMonitorSkeletonClass))
#define XDP_DBUS_NETWORK_MONITOR_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_NETWORK_MONITOR_SKELETON, XdpDbusNetworkMonitorSkeletonClass))
#define XDP_DBUS_IS_NETWORK_MONITOR_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_NETWORK_MONITOR_SKELETON))
#define XDP_DBUS_IS_NETWORK_MONITOR_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_NETWORK_MONITOR_SKELETON))

typedef struct _XdpDbusNetworkMonitorSkeleton XdpDbusNetworkMonitorSkeleton;
typedef struct _XdpDbusNetworkMonitorSkeletonClass XdpDbusNetworkMonitorSkeletonClass;
typedef struct _XdpDbusNetworkMonitorSkeletonPrivate XdpDbusNetworkMonitorSkeletonPrivate;

struct _XdpDbusNetworkMonitorSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusNetworkMonitorSkeletonPrivate *priv;
};

struct _XdpDbusNetworkMonitorSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_network_monitor_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusNetworkMonitor *xdp_dbus_network_monitor_skeleton_new (void);


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

#define XDP_DBUS_TYPE_NOTIFICATION (xdp_dbus_notification_get_type ())
#define XDP_DBUS_NOTIFICATION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_NOTIFICATION, XdpDbusNotification))
#define XDP_DBUS_IS_NOTIFICATION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_NOTIFICATION))
#define XDP_DBUS_NOTIFICATION_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_NOTIFICATION, XdpDbusNotificationIface))

struct _XdpDbusNotification;
typedef struct _XdpDbusNotification XdpDbusNotification;
typedef struct _XdpDbusNotificationIface XdpDbusNotificationIface;

struct _XdpDbusNotificationIface
{
  GTypeInterface parent_iface;



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

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

  GVariant * (*get_supported_options) (XdpDbusNotification *object);

  guint  (*get_version) (XdpDbusNotification *object);

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

};

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

GType xdp_dbus_notification_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_notification_interface_info (void);
guint xdp_dbus_notification_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_dbus_notification_complete_remove_notification (
    XdpDbusNotification *object,
    GDBusMethodInvocation *invocation);



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



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

gboolean xdp_dbus_notification_call_add_notification_finish (
    XdpDbusNotification *proxy,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_notification_call_add_notification_sync (
    XdpDbusNotification *proxy,
    const gchar *arg_id,
    GVariant *arg_notification,
    GUnixFDList  *fd_list,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_notification_call_remove_notification (
    XdpDbusNotification *proxy,
    const gchar *arg_id,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_notification_call_remove_notification_finish (
    XdpDbusNotification *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_notification_call_remove_notification_sync (
    XdpDbusNotification *proxy,
    const gchar *arg_id,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
GVariant *xdp_dbus_notification_get_supported_options (XdpDbusNotification *object);
GVariant *xdp_dbus_notification_dup_supported_options (XdpDbusNotification *object);
void xdp_dbus_notification_set_supported_options (XdpDbusNotification *object, GVariant *value);

guint xdp_dbus_notification_get_version (XdpDbusNotification *object);
void xdp_dbus_notification_set_version (XdpDbusNotification *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_NOTIFICATION_PROXY (xdp_dbus_notification_proxy_get_type ())
#define XDP_DBUS_NOTIFICATION_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_NOTIFICATION_PROXY, XdpDbusNotificationProxy))
#define XDP_DBUS_NOTIFICATION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_NOTIFICATION_PROXY, XdpDbusNotificationProxyClass))
#define XDP_DBUS_NOTIFICATION_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_NOTIFICATION_PROXY, XdpDbusNotificationProxyClass))
#define XDP_DBUS_IS_NOTIFICATION_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_NOTIFICATION_PROXY))
#define XDP_DBUS_IS_NOTIFICATION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_NOTIFICATION_PROXY))

typedef struct _XdpDbusNotificationProxy XdpDbusNotificationProxy;
typedef struct _XdpDbusNotificationProxyClass XdpDbusNotificationProxyClass;
typedef struct _XdpDbusNotificationProxyPrivate XdpDbusNotificationProxyPrivate;

struct _XdpDbusNotificationProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusNotificationProxyPrivate *priv;
};

struct _XdpDbusNotificationProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_notification_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_notification_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusNotification *xdp_dbus_notification_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusNotification *xdp_dbus_notification_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_notification_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusNotification *xdp_dbus_notification_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusNotification *xdp_dbus_notification_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_NOTIFICATION_SKELETON (xdp_dbus_notification_skeleton_get_type ())
#define XDP_DBUS_NOTIFICATION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_NOTIFICATION_SKELETON, XdpDbusNotificationSkeleton))
#define XDP_DBUS_NOTIFICATION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_NOTIFICATION_SKELETON, XdpDbusNotificationSkeletonClass))
#define XDP_DBUS_NOTIFICATION_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_NOTIFICATION_SKELETON, XdpDbusNotificationSkeletonClass))
#define XDP_DBUS_IS_NOTIFICATION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_NOTIFICATION_SKELETON))
#define XDP_DBUS_IS_NOTIFICATION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_NOTIFICATION_SKELETON))

typedef struct _XdpDbusNotificationSkeleton XdpDbusNotificationSkeleton;
typedef struct _XdpDbusNotificationSkeletonClass XdpDbusNotificationSkeletonClass;
typedef struct _XdpDbusNotificationSkeletonPrivate XdpDbusNotificationSkeletonPrivate;

struct _XdpDbusNotificationSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusNotificationSkeletonPrivate *priv;
};

struct _XdpDbusNotificationSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_notification_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusNotification *xdp_dbus_notification_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.OpenURI */

#define XDP_DBUS_TYPE_OPEN_URI (xdp_dbus_open_uri_get_type ())
#define XDP_DBUS_OPEN_URI(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_OPEN_URI, XdpDbusOpenURI))
#define XDP_DBUS_IS_OPEN_URI(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_OPEN_URI))
#define XDP_DBUS_OPEN_URI_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_OPEN_URI, XdpDbusOpenURIIface))

struct _XdpDbusOpenURI;
typedef struct _XdpDbusOpenURI XdpDbusOpenURI;
typedef struct _XdpDbusOpenURIIface XdpDbusOpenURIIface;

struct _XdpDbusOpenURIIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_open_directory) (
    XdpDbusOpenURI *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_parent_window,
    GVariant *arg_fd,
    GVariant *arg_options);

  gboolean (*handle_open_file) (
    XdpDbusOpenURI *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_parent_window,
    GVariant *arg_fd,
    GVariant *arg_options);

  gboolean (*handle_open_uri) (
    XdpDbusOpenURI *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_parent_window,
    const gchar *arg_uri,
    GVariant *arg_options);

  gboolean (*handle_scheme_supported) (
    XdpDbusOpenURI *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_scheme,
    GVariant *arg_options);

  guint  (*get_version) (XdpDbusOpenURI *object);

};

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

GType xdp_dbus_open_uri_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_open_uri_interface_info (void);
guint xdp_dbus_open_uri_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_open_uri_complete_open_uri (
    XdpDbusOpenURI *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_open_uri_complete_open_file (
    XdpDbusOpenURI *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *handle);

void xdp_dbus_open_uri_complete_open_directory (
    XdpDbusOpenURI *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *handle);

void xdp_dbus_open_uri_complete_scheme_supported (
    XdpDbusOpenURI *object,
    GDBusMethodInvocation *invocation,
    gboolean supported);



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

gboolean xdp_dbus_open_uri_call_open_uri_finish (
    XdpDbusOpenURI *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_open_uri_call_open_uri_sync (
    XdpDbusOpenURI *proxy,
    const gchar *arg_parent_window,
    const gchar *arg_uri,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_open_uri_call_open_file (
    XdpDbusOpenURI *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_open_uri_call_open_file_finish (
    XdpDbusOpenURI *proxy,
    gchar ** out_handle,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_open_uri_call_open_file_sync (
    XdpDbusOpenURI *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    gchar ** out_handle,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_open_uri_call_open_directory (
    XdpDbusOpenURI *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_open_uri_call_open_directory_finish (
    XdpDbusOpenURI *proxy,
    gchar ** out_handle,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_open_uri_call_open_directory_sync (
    XdpDbusOpenURI *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    gchar ** out_handle,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_open_uri_call_scheme_supported (
    XdpDbusOpenURI *proxy,
    const gchar *arg_scheme,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_open_uri_call_scheme_supported_finish (
    XdpDbusOpenURI *proxy,
    gboolean* out_supported,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_open_uri_call_scheme_supported_sync (
    XdpDbusOpenURI *proxy,
    const gchar *arg_scheme,
    GVariant *arg_options,
    gboolean* out_supported,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_open_uri_get_version (XdpDbusOpenURI *object);
void xdp_dbus_open_uri_set_version (XdpDbusOpenURI *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_OPEN_URI_PROXY (xdp_dbus_open_uri_proxy_get_type ())
#define XDP_DBUS_OPEN_URI_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_OPEN_URI_PROXY, XdpDbusOpenURIProxy))
#define XDP_DBUS_OPEN_URI_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_OPEN_URI_PROXY, XdpDbusOpenURIProxyClass))
#define XDP_DBUS_OPEN_URI_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_OPEN_URI_PROXY, XdpDbusOpenURIProxyClass))
#define XDP_DBUS_IS_OPEN_URI_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_OPEN_URI_PROXY))
#define XDP_DBUS_IS_OPEN_URI_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_OPEN_URI_PROXY))

typedef struct _XdpDbusOpenURIProxy XdpDbusOpenURIProxy;
typedef struct _XdpDbusOpenURIProxyClass XdpDbusOpenURIProxyClass;
typedef struct _XdpDbusOpenURIProxyPrivate XdpDbusOpenURIProxyPrivate;

struct _XdpDbusOpenURIProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusOpenURIProxyPrivate *priv;
};

struct _XdpDbusOpenURIProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_open_uri_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_open_uri_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusOpenURI *xdp_dbus_open_uri_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusOpenURI *xdp_dbus_open_uri_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_open_uri_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusOpenURI *xdp_dbus_open_uri_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusOpenURI *xdp_dbus_open_uri_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_OPEN_URI_SKELETON (xdp_dbus_open_uri_skeleton_get_type ())
#define XDP_DBUS_OPEN_URI_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_OPEN_URI_SKELETON, XdpDbusOpenURISkeleton))
#define XDP_DBUS_OPEN_URI_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_OPEN_URI_SKELETON, XdpDbusOpenURISkeletonClass))
#define XDP_DBUS_OPEN_URI_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_OPEN_URI_SKELETON, XdpDbusOpenURISkeletonClass))
#define XDP_DBUS_IS_OPEN_URI_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_OPEN_URI_SKELETON))
#define XDP_DBUS_IS_OPEN_URI_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_OPEN_URI_SKELETON))

typedef struct _XdpDbusOpenURISkeleton XdpDbusOpenURISkeleton;
typedef struct _XdpDbusOpenURISkeletonClass XdpDbusOpenURISkeletonClass;
typedef struct _XdpDbusOpenURISkeletonPrivate XdpDbusOpenURISkeletonPrivate;

struct _XdpDbusOpenURISkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusOpenURISkeletonPrivate *priv;
};

struct _XdpDbusOpenURISkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_open_uri_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusOpenURI *xdp_dbus_open_uri_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.PowerProfileMonitor */

#define XDP_DBUS_TYPE_POWER_PROFILE_MONITOR (xdp_dbus_power_profile_monitor_get_type ())
#define XDP_DBUS_POWER_PROFILE_MONITOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_POWER_PROFILE_MONITOR, XdpDbusPowerProfileMonitor))
#define XDP_DBUS_IS_POWER_PROFILE_MONITOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_POWER_PROFILE_MONITOR))
#define XDP_DBUS_POWER_PROFILE_MONITOR_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_POWER_PROFILE_MONITOR, XdpDbusPowerProfileMonitorIface))

struct _XdpDbusPowerProfileMonitor;
typedef struct _XdpDbusPowerProfileMonitor XdpDbusPowerProfileMonitor;
typedef struct _XdpDbusPowerProfileMonitorIface XdpDbusPowerProfileMonitorIface;

struct _XdpDbusPowerProfileMonitorIface
{
  GTypeInterface parent_iface;

  gboolean  (*get_power_saver_enabled) (XdpDbusPowerProfileMonitor *object);

  guint  (*get_version) (XdpDbusPowerProfileMonitor *object);

};

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

GType xdp_dbus_power_profile_monitor_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_power_profile_monitor_interface_info (void);
guint xdp_dbus_power_profile_monitor_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus property accessors: */
gboolean xdp_dbus_power_profile_monitor_get_power_saver_enabled (XdpDbusPowerProfileMonitor *object);
void xdp_dbus_power_profile_monitor_set_power_saver_enabled (XdpDbusPowerProfileMonitor *object, gboolean value);

guint xdp_dbus_power_profile_monitor_get_version (XdpDbusPowerProfileMonitor *object);
void xdp_dbus_power_profile_monitor_set_version (XdpDbusPowerProfileMonitor *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_POWER_PROFILE_MONITOR_PROXY (xdp_dbus_power_profile_monitor_proxy_get_type ())
#define XDP_DBUS_POWER_PROFILE_MONITOR_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_POWER_PROFILE_MONITOR_PROXY, XdpDbusPowerProfileMonitorProxy))
#define XDP_DBUS_POWER_PROFILE_MONITOR_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_POWER_PROFILE_MONITOR_PROXY, XdpDbusPowerProfileMonitorProxyClass))
#define XDP_DBUS_POWER_PROFILE_MONITOR_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_POWER_PROFILE_MONITOR_PROXY, XdpDbusPowerProfileMonitorProxyClass))
#define XDP_DBUS_IS_POWER_PROFILE_MONITOR_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_POWER_PROFILE_MONITOR_PROXY))
#define XDP_DBUS_IS_POWER_PROFILE_MONITOR_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_POWER_PROFILE_MONITOR_PROXY))

typedef struct _XdpDbusPowerProfileMonitorProxy XdpDbusPowerProfileMonitorProxy;
typedef struct _XdpDbusPowerProfileMonitorProxyClass XdpDbusPowerProfileMonitorProxyClass;
typedef struct _XdpDbusPowerProfileMonitorProxyPrivate XdpDbusPowerProfileMonitorProxyPrivate;

struct _XdpDbusPowerProfileMonitorProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusPowerProfileMonitorProxyPrivate *priv;
};

struct _XdpDbusPowerProfileMonitorProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_power_profile_monitor_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_power_profile_monitor_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusPowerProfileMonitor *xdp_dbus_power_profile_monitor_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusPowerProfileMonitor *xdp_dbus_power_profile_monitor_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_power_profile_monitor_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusPowerProfileMonitor *xdp_dbus_power_profile_monitor_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusPowerProfileMonitor *xdp_dbus_power_profile_monitor_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_POWER_PROFILE_MONITOR_SKELETON (xdp_dbus_power_profile_monitor_skeleton_get_type ())
#define XDP_DBUS_POWER_PROFILE_MONITOR_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_POWER_PROFILE_MONITOR_SKELETON, XdpDbusPowerProfileMonitorSkeleton))
#define XDP_DBUS_POWER_PROFILE_MONITOR_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_POWER_PROFILE_MONITOR_SKELETON, XdpDbusPowerProfileMonitorSkeletonClass))
#define XDP_DBUS_POWER_PROFILE_MONITOR_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_POWER_PROFILE_MONITOR_SKELETON, XdpDbusPowerProfileMonitorSkeletonClass))
#define XDP_DBUS_IS_POWER_PROFILE_MONITOR_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_POWER_PROFILE_MONITOR_SKELETON))
#define XDP_DBUS_IS_POWER_PROFILE_MONITOR_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_POWER_PROFILE_MONITOR_SKELETON))

typedef struct _XdpDbusPowerProfileMonitorSkeleton XdpDbusPowerProfileMonitorSkeleton;
typedef struct _XdpDbusPowerProfileMonitorSkeletonClass XdpDbusPowerProfileMonitorSkeletonClass;
typedef struct _XdpDbusPowerProfileMonitorSkeletonPrivate XdpDbusPowerProfileMonitorSkeletonPrivate;

struct _XdpDbusPowerProfileMonitorSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusPowerProfileMonitorSkeletonPrivate *priv;
};

struct _XdpDbusPowerProfileMonitorSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_power_profile_monitor_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusPowerProfileMonitor *xdp_dbus_power_profile_monitor_skeleton_new (void);


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

#define XDP_DBUS_TYPE_PRINT (xdp_dbus_print_get_type ())
#define XDP_DBUS_PRINT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_PRINT, XdpDbusPrint))
#define XDP_DBUS_IS_PRINT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_PRINT))
#define XDP_DBUS_PRINT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_PRINT, XdpDbusPrintIface))

struct _XdpDbusPrint;
typedef struct _XdpDbusPrint XdpDbusPrint;
typedef struct _XdpDbusPrintIface XdpDbusPrintIface;

struct _XdpDbusPrintIface
{
  GTypeInterface parent_iface;


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

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

  guint  (*get_version) (XdpDbusPrint *object);

};

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

GType xdp_dbus_print_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_print_interface_info (void);
guint xdp_dbus_print_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_print_complete_prepare_print (
    XdpDbusPrint *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_print_complete_print (
    XdpDbusPrint *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *handle);



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

gboolean xdp_dbus_print_call_prepare_print_finish (
    XdpDbusPrint *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_print_call_prepare_print_sync (
    XdpDbusPrint *proxy,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_settings,
    GVariant *arg_page_setup,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_print_call_print (
    XdpDbusPrint *proxy,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_print_call_print_finish (
    XdpDbusPrint *proxy,
    gchar ** out_handle,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_print_call_print_sync (
    XdpDbusPrint *proxy,
    const gchar *arg_parent_window,
    const gchar *arg_title,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    gchar ** out_handle,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_print_get_version (XdpDbusPrint *object);
void xdp_dbus_print_set_version (XdpDbusPrint *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_PRINT_PROXY (xdp_dbus_print_proxy_get_type ())
#define XDP_DBUS_PRINT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_PRINT_PROXY, XdpDbusPrintProxy))
#define XDP_DBUS_PRINT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_PRINT_PROXY, XdpDbusPrintProxyClass))
#define XDP_DBUS_PRINT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_PRINT_PROXY, XdpDbusPrintProxyClass))
#define XDP_DBUS_IS_PRINT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_PRINT_PROXY))
#define XDP_DBUS_IS_PRINT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_PRINT_PROXY))

typedef struct _XdpDbusPrintProxy XdpDbusPrintProxy;
typedef struct _XdpDbusPrintProxyClass XdpDbusPrintProxyClass;
typedef struct _XdpDbusPrintProxyPrivate XdpDbusPrintProxyPrivate;

struct _XdpDbusPrintProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusPrintProxyPrivate *priv;
};

struct _XdpDbusPrintProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_print_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_print_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusPrint *xdp_dbus_print_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusPrint *xdp_dbus_print_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_print_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusPrint *xdp_dbus_print_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusPrint *xdp_dbus_print_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_PRINT_SKELETON (xdp_dbus_print_skeleton_get_type ())
#define XDP_DBUS_PRINT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_PRINT_SKELETON, XdpDbusPrintSkeleton))
#define XDP_DBUS_PRINT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_PRINT_SKELETON, XdpDbusPrintSkeletonClass))
#define XDP_DBUS_PRINT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_PRINT_SKELETON, XdpDbusPrintSkeletonClass))
#define XDP_DBUS_IS_PRINT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_PRINT_SKELETON))
#define XDP_DBUS_IS_PRINT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_PRINT_SKELETON))

typedef struct _XdpDbusPrintSkeleton XdpDbusPrintSkeleton;
typedef struct _XdpDbusPrintSkeletonClass XdpDbusPrintSkeletonClass;
typedef struct _XdpDbusPrintSkeletonPrivate XdpDbusPrintSkeletonPrivate;

struct _XdpDbusPrintSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusPrintSkeletonPrivate *priv;
};

struct _XdpDbusPrintSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_print_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusPrint *xdp_dbus_print_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.ProxyResolver */

#define XDP_DBUS_TYPE_PROXY_RESOLVER (xdp_dbus_proxy_resolver_get_type ())
#define XDP_DBUS_PROXY_RESOLVER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_PROXY_RESOLVER, XdpDbusProxyResolver))
#define XDP_DBUS_IS_PROXY_RESOLVER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_PROXY_RESOLVER))
#define XDP_DBUS_PROXY_RESOLVER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_PROXY_RESOLVER, XdpDbusProxyResolverIface))

struct _XdpDbusProxyResolver;
typedef struct _XdpDbusProxyResolver XdpDbusProxyResolver;
typedef struct _XdpDbusProxyResolverIface XdpDbusProxyResolverIface;

struct _XdpDbusProxyResolverIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_lookup) (
    XdpDbusProxyResolver *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_uri);

  guint  (*get_version) (XdpDbusProxyResolver *object);

};

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

GType xdp_dbus_proxy_resolver_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_proxy_resolver_interface_info (void);
guint xdp_dbus_proxy_resolver_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_proxy_resolver_complete_lookup (
    XdpDbusProxyResolver *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *proxies);



/* D-Bus method calls: */
void xdp_dbus_proxy_resolver_call_lookup (
    XdpDbusProxyResolver *proxy,
    const gchar *arg_uri,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_proxy_resolver_call_lookup_finish (
    XdpDbusProxyResolver *proxy,
    gchar *** out_proxies,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_proxy_resolver_call_lookup_sync (
    XdpDbusProxyResolver *proxy,
    const gchar *arg_uri,
    gchar *** out_proxies,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_proxy_resolver_get_version (XdpDbusProxyResolver *object);
void xdp_dbus_proxy_resolver_set_version (XdpDbusProxyResolver *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_PROXY_RESOLVER_PROXY (xdp_dbus_proxy_resolver_proxy_get_type ())
#define XDP_DBUS_PROXY_RESOLVER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_PROXY_RESOLVER_PROXY, XdpDbusProxyResolverProxy))
#define XDP_DBUS_PROXY_RESOLVER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_PROXY_RESOLVER_PROXY, XdpDbusProxyResolverProxyClass))
#define XDP_DBUS_PROXY_RESOLVER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_PROXY_RESOLVER_PROXY, XdpDbusProxyResolverProxyClass))
#define XDP_DBUS_IS_PROXY_RESOLVER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_PROXY_RESOLVER_PROXY))
#define XDP_DBUS_IS_PROXY_RESOLVER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_PROXY_RESOLVER_PROXY))

typedef struct _XdpDbusProxyResolverProxy XdpDbusProxyResolverProxy;
typedef struct _XdpDbusProxyResolverProxyClass XdpDbusProxyResolverProxyClass;
typedef struct _XdpDbusProxyResolverProxyPrivate XdpDbusProxyResolverProxyPrivate;

struct _XdpDbusProxyResolverProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusProxyResolverProxyPrivate *priv;
};

struct _XdpDbusProxyResolverProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_proxy_resolver_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_proxy_resolver_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusProxyResolver *xdp_dbus_proxy_resolver_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusProxyResolver *xdp_dbus_proxy_resolver_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_proxy_resolver_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusProxyResolver *xdp_dbus_proxy_resolver_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusProxyResolver *xdp_dbus_proxy_resolver_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_PROXY_RESOLVER_SKELETON (xdp_dbus_proxy_resolver_skeleton_get_type ())
#define XDP_DBUS_PROXY_RESOLVER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_PROXY_RESOLVER_SKELETON, XdpDbusProxyResolverSkeleton))
#define XDP_DBUS_PROXY_RESOLVER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_PROXY_RESOLVER_SKELETON, XdpDbusProxyResolverSkeletonClass))
#define XDP_DBUS_PROXY_RESOLVER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_PROXY_RESOLVER_SKELETON, XdpDbusProxyResolverSkeletonClass))
#define XDP_DBUS_IS_PROXY_RESOLVER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_PROXY_RESOLVER_SKELETON))
#define XDP_DBUS_IS_PROXY_RESOLVER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_PROXY_RESOLVER_SKELETON))

typedef struct _XdpDbusProxyResolverSkeleton XdpDbusProxyResolverSkeleton;
typedef struct _XdpDbusProxyResolverSkeletonClass XdpDbusProxyResolverSkeletonClass;
typedef struct _XdpDbusProxyResolverSkeletonPrivate XdpDbusProxyResolverSkeletonPrivate;

struct _XdpDbusProxyResolverSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusProxyResolverSkeletonPrivate *priv;
};

struct _XdpDbusProxyResolverSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_proxy_resolver_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusProxyResolver *xdp_dbus_proxy_resolver_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.Realtime */

#define XDP_DBUS_TYPE_REALTIME (xdp_dbus_realtime_get_type ())
#define XDP_DBUS_REALTIME(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_REALTIME, XdpDbusRealtime))
#define XDP_DBUS_IS_REALTIME(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_REALTIME))
#define XDP_DBUS_REALTIME_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_REALTIME, XdpDbusRealtimeIface))

struct _XdpDbusRealtime;
typedef struct _XdpDbusRealtime XdpDbusRealtime;
typedef struct _XdpDbusRealtimeIface XdpDbusRealtimeIface;

struct _XdpDbusRealtimeIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_make_thread_high_priority_with_pid) (
    XdpDbusRealtime *object,
    GDBusMethodInvocation *invocation,
    guint64 arg_process,
    guint64 arg_thread,
    gint arg_priority);

  gboolean (*handle_make_thread_realtime_with_pid) (
    XdpDbusRealtime *object,
    GDBusMethodInvocation *invocation,
    guint64 arg_process,
    guint64 arg_thread,
    guint arg_priority);

  gint  (*get_max_realtime_priority) (XdpDbusRealtime *object);

  gint  (*get_min_nice_level) (XdpDbusRealtime *object);

  gint64  (*get_rttime_usec_max) (XdpDbusRealtime *object);

  guint  (*get_version) (XdpDbusRealtime *object);

};

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

GType xdp_dbus_realtime_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_realtime_interface_info (void);
guint xdp_dbus_realtime_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_dbus_realtime_complete_make_thread_high_priority_with_pid (
    XdpDbusRealtime *object,
    GDBusMethodInvocation *invocation);



/* D-Bus method calls: */
void xdp_dbus_realtime_call_make_thread_realtime_with_pid (
    XdpDbusRealtime *proxy,
    guint64 arg_process,
    guint64 arg_thread,
    guint arg_priority,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_realtime_call_make_thread_realtime_with_pid_finish (
    XdpDbusRealtime *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_realtime_call_make_thread_realtime_with_pid_sync (
    XdpDbusRealtime *proxy,
    guint64 arg_process,
    guint64 arg_thread,
    guint arg_priority,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_realtime_call_make_thread_high_priority_with_pid (
    XdpDbusRealtime *proxy,
    guint64 arg_process,
    guint64 arg_thread,
    gint arg_priority,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_realtime_call_make_thread_high_priority_with_pid_finish (
    XdpDbusRealtime *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_realtime_call_make_thread_high_priority_with_pid_sync (
    XdpDbusRealtime *proxy,
    guint64 arg_process,
    guint64 arg_thread,
    gint arg_priority,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
gint xdp_dbus_realtime_get_max_realtime_priority (XdpDbusRealtime *object);
void xdp_dbus_realtime_set_max_realtime_priority (XdpDbusRealtime *object, gint value);

gint xdp_dbus_realtime_get_min_nice_level (XdpDbusRealtime *object);
void xdp_dbus_realtime_set_min_nice_level (XdpDbusRealtime *object, gint value);

gint64 xdp_dbus_realtime_get_rttime_usec_max (XdpDbusRealtime *object);
void xdp_dbus_realtime_set_rttime_usec_max (XdpDbusRealtime *object, gint64 value);

guint xdp_dbus_realtime_get_version (XdpDbusRealtime *object);
void xdp_dbus_realtime_set_version (XdpDbusRealtime *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_REALTIME_PROXY (xdp_dbus_realtime_proxy_get_type ())
#define XDP_DBUS_REALTIME_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_REALTIME_PROXY, XdpDbusRealtimeProxy))
#define XDP_DBUS_REALTIME_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_REALTIME_PROXY, XdpDbusRealtimeProxyClass))
#define XDP_DBUS_REALTIME_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_REALTIME_PROXY, XdpDbusRealtimeProxyClass))
#define XDP_DBUS_IS_REALTIME_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_REALTIME_PROXY))
#define XDP_DBUS_IS_REALTIME_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_REALTIME_PROXY))

typedef struct _XdpDbusRealtimeProxy XdpDbusRealtimeProxy;
typedef struct _XdpDbusRealtimeProxyClass XdpDbusRealtimeProxyClass;
typedef struct _XdpDbusRealtimeProxyPrivate XdpDbusRealtimeProxyPrivate;

struct _XdpDbusRealtimeProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusRealtimeProxyPrivate *priv;
};

struct _XdpDbusRealtimeProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_realtime_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_realtime_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusRealtime *xdp_dbus_realtime_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusRealtime *xdp_dbus_realtime_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_realtime_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusRealtime *xdp_dbus_realtime_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusRealtime *xdp_dbus_realtime_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_REALTIME_SKELETON (xdp_dbus_realtime_skeleton_get_type ())
#define XDP_DBUS_REALTIME_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_REALTIME_SKELETON, XdpDbusRealtimeSkeleton))
#define XDP_DBUS_REALTIME_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_REALTIME_SKELETON, XdpDbusRealtimeSkeletonClass))
#define XDP_DBUS_REALTIME_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_REALTIME_SKELETON, XdpDbusRealtimeSkeletonClass))
#define XDP_DBUS_IS_REALTIME_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_REALTIME_SKELETON))
#define XDP_DBUS_IS_REALTIME_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_REALTIME_SKELETON))

typedef struct _XdpDbusRealtimeSkeleton XdpDbusRealtimeSkeleton;
typedef struct _XdpDbusRealtimeSkeletonClass XdpDbusRealtimeSkeletonClass;
typedef struct _XdpDbusRealtimeSkeletonPrivate XdpDbusRealtimeSkeletonPrivate;

struct _XdpDbusRealtimeSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusRealtimeSkeletonPrivate *priv;
};

struct _XdpDbusRealtimeSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_realtime_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusRealtime *xdp_dbus_realtime_skeleton_new (void);


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

#define XDP_DBUS_TYPE_REMOTE_DESKTOP (xdp_dbus_remote_desktop_get_type ())
#define XDP_DBUS_REMOTE_DESKTOP(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_REMOTE_DESKTOP, XdpDbusRemoteDesktop))
#define XDP_DBUS_IS_REMOTE_DESKTOP(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_REMOTE_DESKTOP))
#define XDP_DBUS_REMOTE_DESKTOP_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_REMOTE_DESKTOP, XdpDbusRemoteDesktopIface))

struct _XdpDbusRemoteDesktop;
typedef struct _XdpDbusRemoteDesktop XdpDbusRemoteDesktop;
typedef struct _XdpDbusRemoteDesktopIface XdpDbusRemoteDesktopIface;

struct _XdpDbusRemoteDesktopIface
{
  GTypeInterface parent_iface;


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

  gboolean (*handle_create_session) (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_options);

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

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

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

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

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

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

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

  gboolean (*handle_select_devices) (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options);

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

  guint  (*get_available_device_types) (XdpDbusRemoteDesktop *object);

  guint  (*get_version) (XdpDbusRemoteDesktop *object);

};

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

GType xdp_dbus_remote_desktop_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_remote_desktop_interface_info (void);
guint xdp_dbus_remote_desktop_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_remote_desktop_complete_create_session (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_remote_desktop_complete_select_devices (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_remote_desktop_complete_start (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_remote_desktop_complete_notify_pointer_motion (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_remote_desktop_complete_notify_pointer_motion_absolute (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_remote_desktop_complete_notify_pointer_button (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_remote_desktop_complete_notify_pointer_axis (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_remote_desktop_complete_notify_pointer_axis_discrete (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_remote_desktop_complete_notify_keyboard_keycode (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_remote_desktop_complete_notify_keyboard_keysym (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_remote_desktop_complete_notify_touch_down (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_remote_desktop_complete_notify_touch_motion (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_remote_desktop_complete_notify_touch_up (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_remote_desktop_complete_connect_to_eis (
    XdpDbusRemoteDesktop *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);



/* D-Bus method calls: */
void xdp_dbus_remote_desktop_call_create_session (
    XdpDbusRemoteDesktop *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_remote_desktop_call_create_session_finish (
    XdpDbusRemoteDesktop *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_remote_desktop_call_create_session_sync (
    XdpDbusRemoteDesktop *proxy,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_remote_desktop_call_select_devices_finish (
    XdpDbusRemoteDesktop *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_remote_desktop_call_select_devices_sync (
    XdpDbusRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_remote_desktop_call_start_finish (
    XdpDbusRemoteDesktop *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_remote_desktop_call_start_sync (
    XdpDbusRemoteDesktop *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_remote_desktop_call_notify_pointer_motion_finish (
    XdpDbusRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_remote_desktop_call_notify_pointer_motion_absolute_finish (
    XdpDbusRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_remote_desktop_call_notify_pointer_button_finish (
    XdpDbusRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_remote_desktop_call_notify_pointer_axis_finish (
    XdpDbusRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_remote_desktop_call_notify_pointer_axis_discrete_finish (
    XdpDbusRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_remote_desktop_call_notify_keyboard_keycode_finish (
    XdpDbusRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_remote_desktop_call_notify_keyboard_keysym_finish (
    XdpDbusRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_remote_desktop_call_notify_touch_down_finish (
    XdpDbusRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_remote_desktop_call_notify_touch_motion_finish (
    XdpDbusRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_remote_desktop_call_notify_touch_up_finish (
    XdpDbusRemoteDesktop *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_dbus_remote_desktop_call_connect_to_eis_finish (
    XdpDbusRemoteDesktop *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

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



/* D-Bus property accessors: */
guint xdp_dbus_remote_desktop_get_available_device_types (XdpDbusRemoteDesktop *object);
void xdp_dbus_remote_desktop_set_available_device_types (XdpDbusRemoteDesktop *object, guint value);

guint xdp_dbus_remote_desktop_get_version (XdpDbusRemoteDesktop *object);
void xdp_dbus_remote_desktop_set_version (XdpDbusRemoteDesktop *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_REMOTE_DESKTOP_PROXY (xdp_dbus_remote_desktop_proxy_get_type ())
#define XDP_DBUS_REMOTE_DESKTOP_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_REMOTE_DESKTOP_PROXY, XdpDbusRemoteDesktopProxy))
#define XDP_DBUS_REMOTE_DESKTOP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_REMOTE_DESKTOP_PROXY, XdpDbusRemoteDesktopProxyClass))
#define XDP_DBUS_REMOTE_DESKTOP_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_REMOTE_DESKTOP_PROXY, XdpDbusRemoteDesktopProxyClass))
#define XDP_DBUS_IS_REMOTE_DESKTOP_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_REMOTE_DESKTOP_PROXY))
#define XDP_DBUS_IS_REMOTE_DESKTOP_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_REMOTE_DESKTOP_PROXY))

typedef struct _XdpDbusRemoteDesktopProxy XdpDbusRemoteDesktopProxy;
typedef struct _XdpDbusRemoteDesktopProxyClass XdpDbusRemoteDesktopProxyClass;
typedef struct _XdpDbusRemoteDesktopProxyPrivate XdpDbusRemoteDesktopProxyPrivate;

struct _XdpDbusRemoteDesktopProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusRemoteDesktopProxyPrivate *priv;
};

struct _XdpDbusRemoteDesktopProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_remote_desktop_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_remote_desktop_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusRemoteDesktop *xdp_dbus_remote_desktop_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusRemoteDesktop *xdp_dbus_remote_desktop_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_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);
XdpDbusRemoteDesktop *xdp_dbus_remote_desktop_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusRemoteDesktop *xdp_dbus_remote_desktop_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_REMOTE_DESKTOP_SKELETON (xdp_dbus_remote_desktop_skeleton_get_type ())
#define XDP_DBUS_REMOTE_DESKTOP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_REMOTE_DESKTOP_SKELETON, XdpDbusRemoteDesktopSkeleton))
#define XDP_DBUS_REMOTE_DESKTOP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_REMOTE_DESKTOP_SKELETON, XdpDbusRemoteDesktopSkeletonClass))
#define XDP_DBUS_REMOTE_DESKTOP_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_REMOTE_DESKTOP_SKELETON, XdpDbusRemoteDesktopSkeletonClass))
#define XDP_DBUS_IS_REMOTE_DESKTOP_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_REMOTE_DESKTOP_SKELETON))
#define XDP_DBUS_IS_REMOTE_DESKTOP_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_REMOTE_DESKTOP_SKELETON))

typedef struct _XdpDbusRemoteDesktopSkeleton XdpDbusRemoteDesktopSkeleton;
typedef struct _XdpDbusRemoteDesktopSkeletonClass XdpDbusRemoteDesktopSkeletonClass;
typedef struct _XdpDbusRemoteDesktopSkeletonPrivate XdpDbusRemoteDesktopSkeletonPrivate;

struct _XdpDbusRemoteDesktopSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusRemoteDesktopSkeletonPrivate *priv;
};

struct _XdpDbusRemoteDesktopSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_remote_desktop_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusRemoteDesktop *xdp_dbus_remote_desktop_skeleton_new (void);


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

#define XDP_DBUS_TYPE_REQUEST (xdp_dbus_request_get_type ())
#define XDP_DBUS_REQUEST(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_REQUEST, XdpDbusRequest))
#define XDP_DBUS_IS_REQUEST(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_REQUEST))
#define XDP_DBUS_REQUEST_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_REQUEST, XdpDbusRequestIface))

struct _XdpDbusRequest;
typedef struct _XdpDbusRequest XdpDbusRequest;
typedef struct _XdpDbusRequestIface XdpDbusRequestIface;

struct _XdpDbusRequestIface
{
  GTypeInterface parent_iface;


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

  void (*response) (
    XdpDbusRequest *object,
    guint arg_response,
    GVariant *arg_results);

};

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

GType xdp_dbus_request_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_request_interface_info (void);
guint xdp_dbus_request_override_properties (GObjectClass *klass, guint property_id_begin);


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



/* D-Bus signal emissions functions: */
void xdp_dbus_request_emit_response (
    XdpDbusRequest *object,
    guint arg_response,
    GVariant *arg_results);



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

gboolean xdp_dbus_request_call_close_finish (
    XdpDbusRequest *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_request_call_close_sync (
    XdpDbusRequest *proxy,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_DBUS_TYPE_REQUEST_PROXY (xdp_dbus_request_proxy_get_type ())
#define XDP_DBUS_REQUEST_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_REQUEST_PROXY, XdpDbusRequestProxy))
#define XDP_DBUS_REQUEST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_REQUEST_PROXY, XdpDbusRequestProxyClass))
#define XDP_DBUS_REQUEST_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_REQUEST_PROXY, XdpDbusRequestProxyClass))
#define XDP_DBUS_IS_REQUEST_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_REQUEST_PROXY))
#define XDP_DBUS_IS_REQUEST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_REQUEST_PROXY))

typedef struct _XdpDbusRequestProxy XdpDbusRequestProxy;
typedef struct _XdpDbusRequestProxyClass XdpDbusRequestProxyClass;
typedef struct _XdpDbusRequestProxyPrivate XdpDbusRequestProxyPrivate;

struct _XdpDbusRequestProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusRequestProxyPrivate *priv;
};

struct _XdpDbusRequestProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_request_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_request_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusRequest *xdp_dbus_request_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusRequest *xdp_dbus_request_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_request_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusRequest *xdp_dbus_request_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusRequest *xdp_dbus_request_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_REQUEST_SKELETON (xdp_dbus_request_skeleton_get_type ())
#define XDP_DBUS_REQUEST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_REQUEST_SKELETON, XdpDbusRequestSkeleton))
#define XDP_DBUS_REQUEST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_REQUEST_SKELETON, XdpDbusRequestSkeletonClass))
#define XDP_DBUS_REQUEST_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_REQUEST_SKELETON, XdpDbusRequestSkeletonClass))
#define XDP_DBUS_IS_REQUEST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_REQUEST_SKELETON))
#define XDP_DBUS_IS_REQUEST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_REQUEST_SKELETON))

typedef struct _XdpDbusRequestSkeleton XdpDbusRequestSkeleton;
typedef struct _XdpDbusRequestSkeletonClass XdpDbusRequestSkeletonClass;
typedef struct _XdpDbusRequestSkeletonPrivate XdpDbusRequestSkeletonPrivate;

struct _XdpDbusRequestSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusRequestSkeletonPrivate *priv;
};

struct _XdpDbusRequestSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_request_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusRequest *xdp_dbus_request_skeleton_new (void);


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

#define XDP_DBUS_TYPE_SCREEN_CAST (xdp_dbus_screen_cast_get_type ())
#define XDP_DBUS_SCREEN_CAST(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SCREEN_CAST, XdpDbusScreenCast))
#define XDP_DBUS_IS_SCREEN_CAST(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SCREEN_CAST))
#define XDP_DBUS_SCREEN_CAST_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_SCREEN_CAST, XdpDbusScreenCastIface))

struct _XdpDbusScreenCast;
typedef struct _XdpDbusScreenCast XdpDbusScreenCast;
typedef struct _XdpDbusScreenCastIface XdpDbusScreenCastIface;

struct _XdpDbusScreenCastIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_create_session) (
    XdpDbusScreenCast *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_options);

  gboolean (*handle_open_pipewire_remote) (
    XdpDbusScreenCast *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_session_handle,
    GVariant *arg_options);

  gboolean (*handle_select_sources) (
    XdpDbusScreenCast *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_session_handle,
    GVariant *arg_options);

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

  guint  (*get_available_cursor_modes) (XdpDbusScreenCast *object);

  guint  (*get_available_source_types) (XdpDbusScreenCast *object);

  guint  (*get_version) (XdpDbusScreenCast *object);

};

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

GType xdp_dbus_screen_cast_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_screen_cast_interface_info (void);
guint xdp_dbus_screen_cast_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_screen_cast_complete_create_session (
    XdpDbusScreenCast *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_screen_cast_complete_select_sources (
    XdpDbusScreenCast *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_screen_cast_complete_start (
    XdpDbusScreenCast *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_screen_cast_complete_open_pipewire_remote (
    XdpDbusScreenCast *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd);



/* D-Bus method calls: */
void xdp_dbus_screen_cast_call_create_session (
    XdpDbusScreenCast *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_screen_cast_call_create_session_finish (
    XdpDbusScreenCast *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_screen_cast_call_create_session_sync (
    XdpDbusScreenCast *proxy,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_screen_cast_call_select_sources_finish (
    XdpDbusScreenCast *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_screen_cast_call_select_sources_sync (
    XdpDbusScreenCast *proxy,
    const gchar *arg_session_handle,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_screen_cast_call_start_finish (
    XdpDbusScreenCast *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_screen_cast_call_start_sync (
    XdpDbusScreenCast *proxy,
    const gchar *arg_session_handle,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_screen_cast_call_open_pipewire_remote_finish (
    XdpDbusScreenCast *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

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



/* D-Bus property accessors: */
guint xdp_dbus_screen_cast_get_available_source_types (XdpDbusScreenCast *object);
void xdp_dbus_screen_cast_set_available_source_types (XdpDbusScreenCast *object, guint value);

guint xdp_dbus_screen_cast_get_available_cursor_modes (XdpDbusScreenCast *object);
void xdp_dbus_screen_cast_set_available_cursor_modes (XdpDbusScreenCast *object, guint value);

guint xdp_dbus_screen_cast_get_version (XdpDbusScreenCast *object);
void xdp_dbus_screen_cast_set_version (XdpDbusScreenCast *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_SCREEN_CAST_PROXY (xdp_dbus_screen_cast_proxy_get_type ())
#define XDP_DBUS_SCREEN_CAST_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SCREEN_CAST_PROXY, XdpDbusScreenCastProxy))
#define XDP_DBUS_SCREEN_CAST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_SCREEN_CAST_PROXY, XdpDbusScreenCastProxyClass))
#define XDP_DBUS_SCREEN_CAST_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_SCREEN_CAST_PROXY, XdpDbusScreenCastProxyClass))
#define XDP_DBUS_IS_SCREEN_CAST_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SCREEN_CAST_PROXY))
#define XDP_DBUS_IS_SCREEN_CAST_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_SCREEN_CAST_PROXY))

typedef struct _XdpDbusScreenCastProxy XdpDbusScreenCastProxy;
typedef struct _XdpDbusScreenCastProxyClass XdpDbusScreenCastProxyClass;
typedef struct _XdpDbusScreenCastProxyPrivate XdpDbusScreenCastProxyPrivate;

struct _XdpDbusScreenCastProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusScreenCastProxyPrivate *priv;
};

struct _XdpDbusScreenCastProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_screen_cast_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_screen_cast_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusScreenCast *xdp_dbus_screen_cast_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusScreenCast *xdp_dbus_screen_cast_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_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);
XdpDbusScreenCast *xdp_dbus_screen_cast_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusScreenCast *xdp_dbus_screen_cast_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_SCREEN_CAST_SKELETON (xdp_dbus_screen_cast_skeleton_get_type ())
#define XDP_DBUS_SCREEN_CAST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SCREEN_CAST_SKELETON, XdpDbusScreenCastSkeleton))
#define XDP_DBUS_SCREEN_CAST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_SCREEN_CAST_SKELETON, XdpDbusScreenCastSkeletonClass))
#define XDP_DBUS_SCREEN_CAST_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_SCREEN_CAST_SKELETON, XdpDbusScreenCastSkeletonClass))
#define XDP_DBUS_IS_SCREEN_CAST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SCREEN_CAST_SKELETON))
#define XDP_DBUS_IS_SCREEN_CAST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_SCREEN_CAST_SKELETON))

typedef struct _XdpDbusScreenCastSkeleton XdpDbusScreenCastSkeleton;
typedef struct _XdpDbusScreenCastSkeletonClass XdpDbusScreenCastSkeletonClass;
typedef struct _XdpDbusScreenCastSkeletonPrivate XdpDbusScreenCastSkeletonPrivate;

struct _XdpDbusScreenCastSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusScreenCastSkeletonPrivate *priv;
};

struct _XdpDbusScreenCastSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_screen_cast_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusScreenCast *xdp_dbus_screen_cast_skeleton_new (void);


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

#define XDP_DBUS_TYPE_SCREENSHOT (xdp_dbus_screenshot_get_type ())
#define XDP_DBUS_SCREENSHOT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SCREENSHOT, XdpDbusScreenshot))
#define XDP_DBUS_IS_SCREENSHOT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SCREENSHOT))
#define XDP_DBUS_SCREENSHOT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_SCREENSHOT, XdpDbusScreenshotIface))

struct _XdpDbusScreenshot;
typedef struct _XdpDbusScreenshot XdpDbusScreenshot;
typedef struct _XdpDbusScreenshotIface XdpDbusScreenshotIface;

struct _XdpDbusScreenshotIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_pick_color) (
    XdpDbusScreenshot *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  gboolean (*handle_screenshot) (
    XdpDbusScreenshot *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  guint  (*get_available_targets) (XdpDbusScreenshot *object);

  guint  (*get_version) (XdpDbusScreenshot *object);

};

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

GType xdp_dbus_screenshot_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_screenshot_interface_info (void);
guint xdp_dbus_screenshot_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_screenshot_complete_screenshot (
    XdpDbusScreenshot *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_screenshot_complete_pick_color (
    XdpDbusScreenshot *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);



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

gboolean xdp_dbus_screenshot_call_screenshot_finish (
    XdpDbusScreenshot *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_screenshot_call_screenshot_sync (
    XdpDbusScreenshot *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_screenshot_call_pick_color (
    XdpDbusScreenshot *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_screenshot_call_pick_color_finish (
    XdpDbusScreenshot *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_screenshot_call_pick_color_sync (
    XdpDbusScreenshot *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_screenshot_get_available_targets (XdpDbusScreenshot *object);
void xdp_dbus_screenshot_set_available_targets (XdpDbusScreenshot *object, guint value);

guint xdp_dbus_screenshot_get_version (XdpDbusScreenshot *object);
void xdp_dbus_screenshot_set_version (XdpDbusScreenshot *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_SCREENSHOT_PROXY (xdp_dbus_screenshot_proxy_get_type ())
#define XDP_DBUS_SCREENSHOT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SCREENSHOT_PROXY, XdpDbusScreenshotProxy))
#define XDP_DBUS_SCREENSHOT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_SCREENSHOT_PROXY, XdpDbusScreenshotProxyClass))
#define XDP_DBUS_SCREENSHOT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_SCREENSHOT_PROXY, XdpDbusScreenshotProxyClass))
#define XDP_DBUS_IS_SCREENSHOT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SCREENSHOT_PROXY))
#define XDP_DBUS_IS_SCREENSHOT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_SCREENSHOT_PROXY))

typedef struct _XdpDbusScreenshotProxy XdpDbusScreenshotProxy;
typedef struct _XdpDbusScreenshotProxyClass XdpDbusScreenshotProxyClass;
typedef struct _XdpDbusScreenshotProxyPrivate XdpDbusScreenshotProxyPrivate;

struct _XdpDbusScreenshotProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusScreenshotProxyPrivate *priv;
};

struct _XdpDbusScreenshotProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_screenshot_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_screenshot_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusScreenshot *xdp_dbus_screenshot_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusScreenshot *xdp_dbus_screenshot_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_screenshot_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusScreenshot *xdp_dbus_screenshot_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusScreenshot *xdp_dbus_screenshot_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_SCREENSHOT_SKELETON (xdp_dbus_screenshot_skeleton_get_type ())
#define XDP_DBUS_SCREENSHOT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SCREENSHOT_SKELETON, XdpDbusScreenshotSkeleton))
#define XDP_DBUS_SCREENSHOT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_SCREENSHOT_SKELETON, XdpDbusScreenshotSkeletonClass))
#define XDP_DBUS_SCREENSHOT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_SCREENSHOT_SKELETON, XdpDbusScreenshotSkeletonClass))
#define XDP_DBUS_IS_SCREENSHOT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SCREENSHOT_SKELETON))
#define XDP_DBUS_IS_SCREENSHOT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_SCREENSHOT_SKELETON))

typedef struct _XdpDbusScreenshotSkeleton XdpDbusScreenshotSkeleton;
typedef struct _XdpDbusScreenshotSkeletonClass XdpDbusScreenshotSkeletonClass;
typedef struct _XdpDbusScreenshotSkeletonPrivate XdpDbusScreenshotSkeletonPrivate;

struct _XdpDbusScreenshotSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusScreenshotSkeletonPrivate *priv;
};

struct _XdpDbusScreenshotSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_screenshot_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusScreenshot *xdp_dbus_screenshot_skeleton_new (void);


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

#define XDP_DBUS_TYPE_SECRET (xdp_dbus_secret_get_type ())
#define XDP_DBUS_SECRET(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SECRET, XdpDbusSecret))
#define XDP_DBUS_IS_SECRET(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SECRET))
#define XDP_DBUS_SECRET_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_SECRET, XdpDbusSecretIface))

struct _XdpDbusSecret;
typedef struct _XdpDbusSecret XdpDbusSecret;
typedef struct _XdpDbusSecretIface XdpDbusSecretIface;

struct _XdpDbusSecretIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_retrieve_secret) (
    XdpDbusSecret *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *arg_fd,
    GVariant *arg_options);

  guint  (*get_version) (XdpDbusSecret *object);

};

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

GType xdp_dbus_secret_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_secret_interface_info (void);
guint xdp_dbus_secret_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_secret_complete_retrieve_secret (
    XdpDbusSecret *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *handle);



/* D-Bus method calls: */
void xdp_dbus_secret_call_retrieve_secret (
    XdpDbusSecret *proxy,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_secret_call_retrieve_secret_finish (
    XdpDbusSecret *proxy,
    gchar ** out_handle,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_secret_call_retrieve_secret_sync (
    XdpDbusSecret *proxy,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    gchar ** out_handle,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_secret_get_version (XdpDbusSecret *object);
void xdp_dbus_secret_set_version (XdpDbusSecret *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_SECRET_PROXY (xdp_dbus_secret_proxy_get_type ())
#define XDP_DBUS_SECRET_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SECRET_PROXY, XdpDbusSecretProxy))
#define XDP_DBUS_SECRET_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_SECRET_PROXY, XdpDbusSecretProxyClass))
#define XDP_DBUS_SECRET_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_SECRET_PROXY, XdpDbusSecretProxyClass))
#define XDP_DBUS_IS_SECRET_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SECRET_PROXY))
#define XDP_DBUS_IS_SECRET_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_SECRET_PROXY))

typedef struct _XdpDbusSecretProxy XdpDbusSecretProxy;
typedef struct _XdpDbusSecretProxyClass XdpDbusSecretProxyClass;
typedef struct _XdpDbusSecretProxyPrivate XdpDbusSecretProxyPrivate;

struct _XdpDbusSecretProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusSecretProxyPrivate *priv;
};

struct _XdpDbusSecretProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_secret_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_secret_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusSecret *xdp_dbus_secret_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusSecret *xdp_dbus_secret_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_secret_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusSecret *xdp_dbus_secret_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusSecret *xdp_dbus_secret_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_SECRET_SKELETON (xdp_dbus_secret_skeleton_get_type ())
#define XDP_DBUS_SECRET_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SECRET_SKELETON, XdpDbusSecretSkeleton))
#define XDP_DBUS_SECRET_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_SECRET_SKELETON, XdpDbusSecretSkeletonClass))
#define XDP_DBUS_SECRET_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_SECRET_SKELETON, XdpDbusSecretSkeletonClass))
#define XDP_DBUS_IS_SECRET_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SECRET_SKELETON))
#define XDP_DBUS_IS_SECRET_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_SECRET_SKELETON))

typedef struct _XdpDbusSecretSkeleton XdpDbusSecretSkeleton;
typedef struct _XdpDbusSecretSkeletonClass XdpDbusSecretSkeletonClass;
typedef struct _XdpDbusSecretSkeletonPrivate XdpDbusSecretSkeletonPrivate;

struct _XdpDbusSecretSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusSecretSkeletonPrivate *priv;
};

struct _XdpDbusSecretSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_secret_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusSecret *xdp_dbus_secret_skeleton_new (void);


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

#define XDP_DBUS_TYPE_SESSION (xdp_dbus_session_get_type ())
#define XDP_DBUS_SESSION(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SESSION, XdpDbusSession))
#define XDP_DBUS_IS_SESSION(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SESSION))
#define XDP_DBUS_SESSION_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_SESSION, XdpDbusSessionIface))

struct _XdpDbusSession;
typedef struct _XdpDbusSession XdpDbusSession;
typedef struct _XdpDbusSessionIface XdpDbusSessionIface;

struct _XdpDbusSessionIface
{
  GTypeInterface parent_iface;



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

  guint  (*get_version) (XdpDbusSession *object);

  void (*closed) (
    XdpDbusSession *object,
    GVariant *arg_details);

};

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

GType xdp_dbus_session_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_session_interface_info (void);
guint xdp_dbus_session_override_properties (GObjectClass *klass, guint property_id_begin);


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



/* D-Bus signal emissions functions: */
void xdp_dbus_session_emit_closed (
    XdpDbusSession *object,
    GVariant *arg_details);



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

gboolean xdp_dbus_session_call_close_finish (
    XdpDbusSession *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_session_call_close_sync (
    XdpDbusSession *proxy,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_session_get_version (XdpDbusSession *object);
void xdp_dbus_session_set_version (XdpDbusSession *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_SESSION_PROXY (xdp_dbus_session_proxy_get_type ())
#define XDP_DBUS_SESSION_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SESSION_PROXY, XdpDbusSessionProxy))
#define XDP_DBUS_SESSION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_SESSION_PROXY, XdpDbusSessionProxyClass))
#define XDP_DBUS_SESSION_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_SESSION_PROXY, XdpDbusSessionProxyClass))
#define XDP_DBUS_IS_SESSION_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SESSION_PROXY))
#define XDP_DBUS_IS_SESSION_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_SESSION_PROXY))

typedef struct _XdpDbusSessionProxy XdpDbusSessionProxy;
typedef struct _XdpDbusSessionProxyClass XdpDbusSessionProxyClass;
typedef struct _XdpDbusSessionProxyPrivate XdpDbusSessionProxyPrivate;

struct _XdpDbusSessionProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusSessionProxyPrivate *priv;
};

struct _XdpDbusSessionProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_session_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_session_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusSession *xdp_dbus_session_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusSession *xdp_dbus_session_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_session_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusSession *xdp_dbus_session_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusSession *xdp_dbus_session_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_SESSION_SKELETON (xdp_dbus_session_skeleton_get_type ())
#define XDP_DBUS_SESSION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SESSION_SKELETON, XdpDbusSessionSkeleton))
#define XDP_DBUS_SESSION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_SESSION_SKELETON, XdpDbusSessionSkeletonClass))
#define XDP_DBUS_SESSION_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_SESSION_SKELETON, XdpDbusSessionSkeletonClass))
#define XDP_DBUS_IS_SESSION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SESSION_SKELETON))
#define XDP_DBUS_IS_SESSION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_SESSION_SKELETON))

typedef struct _XdpDbusSessionSkeleton XdpDbusSessionSkeleton;
typedef struct _XdpDbusSessionSkeletonClass XdpDbusSessionSkeletonClass;
typedef struct _XdpDbusSessionSkeletonPrivate XdpDbusSessionSkeletonPrivate;

struct _XdpDbusSessionSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusSessionSkeletonPrivate *priv;
};

struct _XdpDbusSessionSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_session_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusSession *xdp_dbus_session_skeleton_new (void);


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

#define XDP_DBUS_TYPE_SETTINGS (xdp_dbus_settings_get_type ())
#define XDP_DBUS_SETTINGS(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SETTINGS, XdpDbusSettings))
#define XDP_DBUS_IS_SETTINGS(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SETTINGS))
#define XDP_DBUS_SETTINGS_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_SETTINGS, XdpDbusSettingsIface))

struct _XdpDbusSettings;
typedef struct _XdpDbusSettings XdpDbusSettings;
typedef struct _XdpDbusSettingsIface XdpDbusSettingsIface;

struct _XdpDbusSettingsIface
{
  GTypeInterface parent_iface;



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

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

  gboolean (*handle_read_one) (
    XdpDbusSettings *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_namespace,
    const gchar *arg_key);

  guint  (*get_version) (XdpDbusSettings *object);

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

};

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

GType xdp_dbus_settings_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_settings_interface_info (void);
guint xdp_dbus_settings_override_properties (GObjectClass *klass, guint property_id_begin);


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

G_GNUC_DEPRECATED void xdp_dbus_settings_complete_read (
    XdpDbusSettings *object,
    GDBusMethodInvocation *invocation,
    GVariant *value);

void xdp_dbus_settings_complete_read_one (
    XdpDbusSettings *object,
    GDBusMethodInvocation *invocation,
    GVariant *value);



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



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

gboolean xdp_dbus_settings_call_read_all_finish (
    XdpDbusSettings *proxy,
    GVariant ** out_value,
    GAsyncResult *res,
    GError **error);

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

G_GNUC_DEPRECATED void xdp_dbus_settings_call_read (
    XdpDbusSettings *proxy,
    const gchar *arg_namespace,
    const gchar *arg_key,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

G_GNUC_DEPRECATED gboolean xdp_dbus_settings_call_read_finish (
    XdpDbusSettings *proxy,
    GVariant ** out_value,
    GAsyncResult *res,
    GError **error);

G_GNUC_DEPRECATED gboolean xdp_dbus_settings_call_read_sync (
    XdpDbusSettings *proxy,
    const gchar *arg_namespace,
    const gchar *arg_key,
    GVariant ** out_value,
    GCancellable *cancellable,
    GError **error);

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

gboolean xdp_dbus_settings_call_read_one_finish (
    XdpDbusSettings *proxy,
    GVariant ** out_value,
    GAsyncResult *res,
    GError **error);

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



/* D-Bus property accessors: */
guint xdp_dbus_settings_get_version (XdpDbusSettings *object);
void xdp_dbus_settings_set_version (XdpDbusSettings *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_SETTINGS_PROXY (xdp_dbus_settings_proxy_get_type ())
#define XDP_DBUS_SETTINGS_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SETTINGS_PROXY, XdpDbusSettingsProxy))
#define XDP_DBUS_SETTINGS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_SETTINGS_PROXY, XdpDbusSettingsProxyClass))
#define XDP_DBUS_SETTINGS_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_SETTINGS_PROXY, XdpDbusSettingsProxyClass))
#define XDP_DBUS_IS_SETTINGS_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SETTINGS_PROXY))
#define XDP_DBUS_IS_SETTINGS_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_SETTINGS_PROXY))

typedef struct _XdpDbusSettingsProxy XdpDbusSettingsProxy;
typedef struct _XdpDbusSettingsProxyClass XdpDbusSettingsProxyClass;
typedef struct _XdpDbusSettingsProxyPrivate XdpDbusSettingsProxyPrivate;

struct _XdpDbusSettingsProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusSettingsProxyPrivate *priv;
};

struct _XdpDbusSettingsProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_settings_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_settings_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusSettings *xdp_dbus_settings_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusSettings *xdp_dbus_settings_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_settings_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusSettings *xdp_dbus_settings_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusSettings *xdp_dbus_settings_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_SETTINGS_SKELETON (xdp_dbus_settings_skeleton_get_type ())
#define XDP_DBUS_SETTINGS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_SETTINGS_SKELETON, XdpDbusSettingsSkeleton))
#define XDP_DBUS_SETTINGS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_SETTINGS_SKELETON, XdpDbusSettingsSkeletonClass))
#define XDP_DBUS_SETTINGS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_SETTINGS_SKELETON, XdpDbusSettingsSkeletonClass))
#define XDP_DBUS_IS_SETTINGS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_SETTINGS_SKELETON))
#define XDP_DBUS_IS_SETTINGS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_SETTINGS_SKELETON))

typedef struct _XdpDbusSettingsSkeleton XdpDbusSettingsSkeleton;
typedef struct _XdpDbusSettingsSkeletonClass XdpDbusSettingsSkeletonClass;
typedef struct _XdpDbusSettingsSkeletonPrivate XdpDbusSettingsSkeletonPrivate;

struct _XdpDbusSettingsSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusSettingsSkeletonPrivate *priv;
};

struct _XdpDbusSettingsSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_settings_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusSettings *xdp_dbus_settings_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.Trash */

#define XDP_DBUS_TYPE_TRASH (xdp_dbus_trash_get_type ())
#define XDP_DBUS_TRASH(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_TRASH, XdpDbusTrash))
#define XDP_DBUS_IS_TRASH(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_TRASH))
#define XDP_DBUS_TRASH_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_TRASH, XdpDbusTrashIface))

struct _XdpDbusTrash;
typedef struct _XdpDbusTrash XdpDbusTrash;
typedef struct _XdpDbusTrashIface XdpDbusTrashIface;

struct _XdpDbusTrashIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_trash_file) (
    XdpDbusTrash *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *arg_fd);

  guint  (*get_version) (XdpDbusTrash *object);

};

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

GType xdp_dbus_trash_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_trash_interface_info (void);
guint xdp_dbus_trash_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_trash_complete_trash_file (
    XdpDbusTrash *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    guint result);



/* D-Bus method calls: */
void xdp_dbus_trash_call_trash_file (
    XdpDbusTrash *proxy,
    GVariant *arg_fd,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_trash_call_trash_file_finish (
    XdpDbusTrash *proxy,
    guint* out_result,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_trash_call_trash_file_sync (
    XdpDbusTrash *proxy,
    GVariant *arg_fd,
    GUnixFDList  *fd_list,
    guint* out_result,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_trash_get_version (XdpDbusTrash *object);
void xdp_dbus_trash_set_version (XdpDbusTrash *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_TRASH_PROXY (xdp_dbus_trash_proxy_get_type ())
#define XDP_DBUS_TRASH_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_TRASH_PROXY, XdpDbusTrashProxy))
#define XDP_DBUS_TRASH_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_TRASH_PROXY, XdpDbusTrashProxyClass))
#define XDP_DBUS_TRASH_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_TRASH_PROXY, XdpDbusTrashProxyClass))
#define XDP_DBUS_IS_TRASH_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_TRASH_PROXY))
#define XDP_DBUS_IS_TRASH_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_TRASH_PROXY))

typedef struct _XdpDbusTrashProxy XdpDbusTrashProxy;
typedef struct _XdpDbusTrashProxyClass XdpDbusTrashProxyClass;
typedef struct _XdpDbusTrashProxyPrivate XdpDbusTrashProxyPrivate;

struct _XdpDbusTrashProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusTrashProxyPrivate *priv;
};

struct _XdpDbusTrashProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_trash_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_trash_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusTrash *xdp_dbus_trash_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusTrash *xdp_dbus_trash_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_trash_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusTrash *xdp_dbus_trash_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusTrash *xdp_dbus_trash_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_TRASH_SKELETON (xdp_dbus_trash_skeleton_get_type ())
#define XDP_DBUS_TRASH_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_TRASH_SKELETON, XdpDbusTrashSkeleton))
#define XDP_DBUS_TRASH_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_TRASH_SKELETON, XdpDbusTrashSkeletonClass))
#define XDP_DBUS_TRASH_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_TRASH_SKELETON, XdpDbusTrashSkeletonClass))
#define XDP_DBUS_IS_TRASH_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_TRASH_SKELETON))
#define XDP_DBUS_IS_TRASH_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_TRASH_SKELETON))

typedef struct _XdpDbusTrashSkeleton XdpDbusTrashSkeleton;
typedef struct _XdpDbusTrashSkeletonClass XdpDbusTrashSkeletonClass;
typedef struct _XdpDbusTrashSkeletonPrivate XdpDbusTrashSkeletonPrivate;

struct _XdpDbusTrashSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusTrashSkeletonPrivate *priv;
};

struct _XdpDbusTrashSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_trash_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusTrash *xdp_dbus_trash_skeleton_new (void);


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

#define XDP_DBUS_TYPE_USB (xdp_dbus_usb_get_type ())
#define XDP_DBUS_USB(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_USB, XdpDbusUsb))
#define XDP_DBUS_IS_USB(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_USB))
#define XDP_DBUS_USB_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_USB, XdpDbusUsbIface))

struct _XdpDbusUsb;
typedef struct _XdpDbusUsb XdpDbusUsb;
typedef struct _XdpDbusUsbIface XdpDbusUsbIface;

struct _XdpDbusUsbIface
{
  GTypeInterface parent_iface;



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

  gboolean (*handle_create_session) (
    XdpDbusUsb *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_options);

  gboolean (*handle_enumerate_devices) (
    XdpDbusUsb *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_options);

  gboolean (*handle_finish_acquire_devices) (
    XdpDbusUsb *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_handle,
    GVariant *arg_options);

  gboolean (*handle_release_devices) (
    XdpDbusUsb *object,
    GDBusMethodInvocation *invocation,
    const gchar *const *arg_devices,
    GVariant *arg_options);

  guint  (*get_version) (XdpDbusUsb *object);

  void (*device_events) (
    XdpDbusUsb *object,
    const gchar *arg_session_handle,
    GVariant *arg_events);

};

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

GType xdp_dbus_usb_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_usb_interface_info (void);
guint xdp_dbus_usb_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_usb_complete_create_session (
    XdpDbusUsb *object,
    GDBusMethodInvocation *invocation,
    const gchar *session_handle);

void xdp_dbus_usb_complete_enumerate_devices (
    XdpDbusUsb *object,
    GDBusMethodInvocation *invocation,
    GVariant *devices);

void xdp_dbus_usb_complete_acquire_devices (
    XdpDbusUsb *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_usb_complete_finish_acquire_devices (
    XdpDbusUsb *object,
    GDBusMethodInvocation *invocation,
    GVariant *results,
    gboolean finished);

void xdp_dbus_usb_complete_release_devices (
    XdpDbusUsb *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void xdp_dbus_usb_emit_device_events (
    XdpDbusUsb *object,
    const gchar *arg_session_handle,
    GVariant *arg_events);



/* D-Bus method calls: */
void xdp_dbus_usb_call_create_session (
    XdpDbusUsb *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_usb_call_create_session_finish (
    XdpDbusUsb *proxy,
    gchar ** out_session_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_usb_call_create_session_sync (
    XdpDbusUsb *proxy,
    GVariant *arg_options,
    gchar ** out_session_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_usb_call_enumerate_devices (
    XdpDbusUsb *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_usb_call_enumerate_devices_finish (
    XdpDbusUsb *proxy,
    GVariant ** out_devices,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_usb_call_enumerate_devices_sync (
    XdpDbusUsb *proxy,
    GVariant *arg_options,
    GVariant ** out_devices,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_usb_call_acquire_devices (
    XdpDbusUsb *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_devices,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_usb_call_acquire_devices_finish (
    XdpDbusUsb *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_usb_call_acquire_devices_sync (
    XdpDbusUsb *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_devices,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_usb_call_finish_acquire_devices (
    XdpDbusUsb *proxy,
    const gchar *arg_handle,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_usb_call_finish_acquire_devices_finish (
    XdpDbusUsb *proxy,
    GVariant ** out_results,
    gboolean* out_finished,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_usb_call_finish_acquire_devices_sync (
    XdpDbusUsb *proxy,
    const gchar *arg_handle,
    GVariant *arg_options,
    GVariant ** out_results,
    gboolean* out_finished,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_usb_call_release_devices (
    XdpDbusUsb *proxy,
    const gchar *const *arg_devices,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_usb_call_release_devices_finish (
    XdpDbusUsb *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_usb_call_release_devices_sync (
    XdpDbusUsb *proxy,
    const gchar *const *arg_devices,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_usb_get_version (XdpDbusUsb *object);
void xdp_dbus_usb_set_version (XdpDbusUsb *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_USB_PROXY (xdp_dbus_usb_proxy_get_type ())
#define XDP_DBUS_USB_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_USB_PROXY, XdpDbusUsbProxy))
#define XDP_DBUS_USB_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_USB_PROXY, XdpDbusUsbProxyClass))
#define XDP_DBUS_USB_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_USB_PROXY, XdpDbusUsbProxyClass))
#define XDP_DBUS_IS_USB_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_USB_PROXY))
#define XDP_DBUS_IS_USB_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_USB_PROXY))

typedef struct _XdpDbusUsbProxy XdpDbusUsbProxy;
typedef struct _XdpDbusUsbProxyClass XdpDbusUsbProxyClass;
typedef struct _XdpDbusUsbProxyPrivate XdpDbusUsbProxyPrivate;

struct _XdpDbusUsbProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusUsbProxyPrivate *priv;
};

struct _XdpDbusUsbProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_usb_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_usb_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusUsb *xdp_dbus_usb_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusUsb *xdp_dbus_usb_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_usb_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusUsb *xdp_dbus_usb_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusUsb *xdp_dbus_usb_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_USB_SKELETON (xdp_dbus_usb_skeleton_get_type ())
#define XDP_DBUS_USB_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_USB_SKELETON, XdpDbusUsbSkeleton))
#define XDP_DBUS_USB_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_USB_SKELETON, XdpDbusUsbSkeletonClass))
#define XDP_DBUS_USB_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_USB_SKELETON, XdpDbusUsbSkeletonClass))
#define XDP_DBUS_IS_USB_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_USB_SKELETON))
#define XDP_DBUS_IS_USB_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_USB_SKELETON))

typedef struct _XdpDbusUsbSkeleton XdpDbusUsbSkeleton;
typedef struct _XdpDbusUsbSkeletonClass XdpDbusUsbSkeletonClass;
typedef struct _XdpDbusUsbSkeletonPrivate XdpDbusUsbSkeletonPrivate;

struct _XdpDbusUsbSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusUsbSkeletonPrivate *priv;
};

struct _XdpDbusUsbSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_usb_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusUsb *xdp_dbus_usb_skeleton_new (void);


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

#define XDP_DBUS_TYPE_WALLPAPER (xdp_dbus_wallpaper_get_type ())
#define XDP_DBUS_WALLPAPER(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_WALLPAPER, XdpDbusWallpaper))
#define XDP_DBUS_IS_WALLPAPER(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_WALLPAPER))
#define XDP_DBUS_WALLPAPER_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_WALLPAPER, XdpDbusWallpaperIface))

struct _XdpDbusWallpaper;
typedef struct _XdpDbusWallpaper XdpDbusWallpaper;
typedef struct _XdpDbusWallpaperIface XdpDbusWallpaperIface;

struct _XdpDbusWallpaperIface
{
  GTypeInterface parent_iface;


  gboolean (*handle_set_wallpaper_file) (
    XdpDbusWallpaper *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_parent_window,
    GVariant *arg_fd,
    GVariant *arg_options);

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

  guint  (*get_version) (XdpDbusWallpaper *object);

};

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

GType xdp_dbus_wallpaper_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_wallpaper_interface_info (void);
guint xdp_dbus_wallpaper_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_wallpaper_complete_set_wallpaper_uri (
    XdpDbusWallpaper *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);

void xdp_dbus_wallpaper_complete_set_wallpaper_file (
    XdpDbusWallpaper *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *handle);



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

gboolean xdp_dbus_wallpaper_call_set_wallpaper_uri_finish (
    XdpDbusWallpaper *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_wallpaper_call_set_wallpaper_uri_sync (
    XdpDbusWallpaper *proxy,
    const gchar *arg_parent_window,
    const gchar *arg_uri,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_wallpaper_call_set_wallpaper_file (
    XdpDbusWallpaper *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_wallpaper_call_set_wallpaper_file_finish (
    XdpDbusWallpaper *proxy,
    gchar ** out_handle,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_wallpaper_call_set_wallpaper_file_sync (
    XdpDbusWallpaper *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    gchar ** out_handle,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_wallpaper_get_version (XdpDbusWallpaper *object);
void xdp_dbus_wallpaper_set_version (XdpDbusWallpaper *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_WALLPAPER_PROXY (xdp_dbus_wallpaper_proxy_get_type ())
#define XDP_DBUS_WALLPAPER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_WALLPAPER_PROXY, XdpDbusWallpaperProxy))
#define XDP_DBUS_WALLPAPER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_WALLPAPER_PROXY, XdpDbusWallpaperProxyClass))
#define XDP_DBUS_WALLPAPER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_WALLPAPER_PROXY, XdpDbusWallpaperProxyClass))
#define XDP_DBUS_IS_WALLPAPER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_WALLPAPER_PROXY))
#define XDP_DBUS_IS_WALLPAPER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_WALLPAPER_PROXY))

typedef struct _XdpDbusWallpaperProxy XdpDbusWallpaperProxy;
typedef struct _XdpDbusWallpaperProxyClass XdpDbusWallpaperProxyClass;
typedef struct _XdpDbusWallpaperProxyPrivate XdpDbusWallpaperProxyPrivate;

struct _XdpDbusWallpaperProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusWallpaperProxyPrivate *priv;
};

struct _XdpDbusWallpaperProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_wallpaper_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_wallpaper_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusWallpaper *xdp_dbus_wallpaper_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusWallpaper *xdp_dbus_wallpaper_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_wallpaper_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusWallpaper *xdp_dbus_wallpaper_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusWallpaper *xdp_dbus_wallpaper_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_WALLPAPER_SKELETON (xdp_dbus_wallpaper_skeleton_get_type ())
#define XDP_DBUS_WALLPAPER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_WALLPAPER_SKELETON, XdpDbusWallpaperSkeleton))
#define XDP_DBUS_WALLPAPER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_WALLPAPER_SKELETON, XdpDbusWallpaperSkeletonClass))
#define XDP_DBUS_WALLPAPER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_WALLPAPER_SKELETON, XdpDbusWallpaperSkeletonClass))
#define XDP_DBUS_IS_WALLPAPER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_WALLPAPER_SKELETON))
#define XDP_DBUS_IS_WALLPAPER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_WALLPAPER_SKELETON))

typedef struct _XdpDbusWallpaperSkeleton XdpDbusWallpaperSkeleton;
typedef struct _XdpDbusWallpaperSkeletonClass XdpDbusWallpaperSkeletonClass;
typedef struct _XdpDbusWallpaperSkeletonPrivate XdpDbusWallpaperSkeletonPrivate;

struct _XdpDbusWallpaperSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusWallpaperSkeletonPrivate *priv;
};

struct _XdpDbusWallpaperSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_wallpaper_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusWallpaper *xdp_dbus_wallpaper_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.Flatpak */

#define XDP_DBUS_TYPE_FLATPAK (xdp_dbus_flatpak_get_type ())
#define XDP_DBUS_FLATPAK(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_FLATPAK, XdpDbusFlatpak))
#define XDP_DBUS_IS_FLATPAK(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_FLATPAK))
#define XDP_DBUS_FLATPAK_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_FLATPAK, XdpDbusFlatpakIface))

struct _XdpDbusFlatpak;
typedef struct _XdpDbusFlatpak XdpDbusFlatpak;
typedef struct _XdpDbusFlatpakIface XdpDbusFlatpakIface;

struct _XdpDbusFlatpakIface
{
  GTypeInterface parent_iface;



  gboolean (*handle_create_update_monitor) (
    XdpDbusFlatpak *object,
    GDBusMethodInvocation *invocation,
    GVariant *arg_options);

  gboolean (*handle_spawn) (
    XdpDbusFlatpak *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *arg_cwd_path,
    const gchar *const *arg_argv,
    GVariant *arg_fds,
    GVariant *arg_envs,
    guint arg_flags,
    GVariant *arg_options);

  gboolean (*handle_spawn_signal) (
    XdpDbusFlatpak *object,
    GDBusMethodInvocation *invocation,
    guint arg_pid,
    guint arg_signal,
    gboolean arg_to_process_group);

  guint  (*get_supports) (XdpDbusFlatpak *object);

  guint  (*get_version) (XdpDbusFlatpak *object);

  void (*spawn_exited) (
    XdpDbusFlatpak *object,
    guint arg_pid,
    guint arg_exit_status);

  void (*spawn_started) (
    XdpDbusFlatpak *object,
    guint arg_pid,
    guint arg_relpid);

};

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

GType xdp_dbus_flatpak_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_flatpak_interface_info (void);
guint xdp_dbus_flatpak_override_properties (GObjectClass *klass, guint property_id_begin);


/* D-Bus method call completion functions: */
void xdp_dbus_flatpak_complete_spawn (
    XdpDbusFlatpak *object,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    guint pid);

void xdp_dbus_flatpak_complete_spawn_signal (
    XdpDbusFlatpak *object,
    GDBusMethodInvocation *invocation);

void xdp_dbus_flatpak_complete_create_update_monitor (
    XdpDbusFlatpak *object,
    GDBusMethodInvocation *invocation,
    const gchar *handle);



/* D-Bus signal emissions functions: */
void xdp_dbus_flatpak_emit_spawn_started (
    XdpDbusFlatpak *object,
    guint arg_pid,
    guint arg_relpid);

void xdp_dbus_flatpak_emit_spawn_exited (
    XdpDbusFlatpak *object,
    guint arg_pid,
    guint arg_exit_status);



/* D-Bus method calls: */
void xdp_dbus_flatpak_call_spawn (
    XdpDbusFlatpak *proxy,
    const gchar *arg_cwd_path,
    const gchar *const *arg_argv,
    GVariant *arg_fds,
    GVariant *arg_envs,
    guint arg_flags,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_flatpak_call_spawn_finish (
    XdpDbusFlatpak *proxy,
    guint* out_pid,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_flatpak_call_spawn_sync (
    XdpDbusFlatpak *proxy,
    const gchar *arg_cwd_path,
    const gchar *const *arg_argv,
    GVariant *arg_fds,
    GVariant *arg_envs,
    guint arg_flags,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    guint* out_pid,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_flatpak_call_spawn_signal (
    XdpDbusFlatpak *proxy,
    guint arg_pid,
    guint arg_signal,
    gboolean arg_to_process_group,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_flatpak_call_spawn_signal_finish (
    XdpDbusFlatpak *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_flatpak_call_spawn_signal_sync (
    XdpDbusFlatpak *proxy,
    guint arg_pid,
    guint arg_signal,
    gboolean arg_to_process_group,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_flatpak_call_create_update_monitor (
    XdpDbusFlatpak *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_flatpak_call_create_update_monitor_finish (
    XdpDbusFlatpak *proxy,
    gchar ** out_handle,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_flatpak_call_create_update_monitor_sync (
    XdpDbusFlatpak *proxy,
    GVariant *arg_options,
    gchar ** out_handle,
    GCancellable *cancellable,
    GError **error);



/* D-Bus property accessors: */
guint xdp_dbus_flatpak_get_version (XdpDbusFlatpak *object);
void xdp_dbus_flatpak_set_version (XdpDbusFlatpak *object, guint value);

guint xdp_dbus_flatpak_get_supports (XdpDbusFlatpak *object);
void xdp_dbus_flatpak_set_supports (XdpDbusFlatpak *object, guint value);


/* ---- */

#define XDP_DBUS_TYPE_FLATPAK_PROXY (xdp_dbus_flatpak_proxy_get_type ())
#define XDP_DBUS_FLATPAK_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_FLATPAK_PROXY, XdpDbusFlatpakProxy))
#define XDP_DBUS_FLATPAK_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_FLATPAK_PROXY, XdpDbusFlatpakProxyClass))
#define XDP_DBUS_FLATPAK_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_FLATPAK_PROXY, XdpDbusFlatpakProxyClass))
#define XDP_DBUS_IS_FLATPAK_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_FLATPAK_PROXY))
#define XDP_DBUS_IS_FLATPAK_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_FLATPAK_PROXY))

typedef struct _XdpDbusFlatpakProxy XdpDbusFlatpakProxy;
typedef struct _XdpDbusFlatpakProxyClass XdpDbusFlatpakProxyClass;
typedef struct _XdpDbusFlatpakProxyPrivate XdpDbusFlatpakProxyPrivate;

struct _XdpDbusFlatpakProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusFlatpakProxyPrivate *priv;
};

struct _XdpDbusFlatpakProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_flatpak_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_flatpak_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusFlatpak *xdp_dbus_flatpak_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusFlatpak *xdp_dbus_flatpak_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_flatpak_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusFlatpak *xdp_dbus_flatpak_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusFlatpak *xdp_dbus_flatpak_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_FLATPAK_SKELETON (xdp_dbus_flatpak_skeleton_get_type ())
#define XDP_DBUS_FLATPAK_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_FLATPAK_SKELETON, XdpDbusFlatpakSkeleton))
#define XDP_DBUS_FLATPAK_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_FLATPAK_SKELETON, XdpDbusFlatpakSkeletonClass))
#define XDP_DBUS_FLATPAK_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_FLATPAK_SKELETON, XdpDbusFlatpakSkeletonClass))
#define XDP_DBUS_IS_FLATPAK_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_FLATPAK_SKELETON))
#define XDP_DBUS_IS_FLATPAK_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_FLATPAK_SKELETON))

typedef struct _XdpDbusFlatpakSkeleton XdpDbusFlatpakSkeleton;
typedef struct _XdpDbusFlatpakSkeletonClass XdpDbusFlatpakSkeletonClass;
typedef struct _XdpDbusFlatpakSkeletonPrivate XdpDbusFlatpakSkeletonPrivate;

struct _XdpDbusFlatpakSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusFlatpakSkeletonPrivate *priv;
};

struct _XdpDbusFlatpakSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_flatpak_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusFlatpak *xdp_dbus_flatpak_skeleton_new (void);


/* ------------------------------------------------------------------------ */
/* Declarations for org.freedesktop.portal.Flatpak.UpdateMonitor */

#define XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR (xdp_dbus_flatpak_update_monitor_get_type ())
#define XDP_DBUS_FLATPAK_UPDATE_MONITOR(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR, XdpDbusFlatpakUpdateMonitor))
#define XDP_DBUS_IS_FLATPAK_UPDATE_MONITOR(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR))
#define XDP_DBUS_FLATPAK_UPDATE_MONITOR_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR, XdpDbusFlatpakUpdateMonitorIface))

struct _XdpDbusFlatpakUpdateMonitor;
typedef struct _XdpDbusFlatpakUpdateMonitor XdpDbusFlatpakUpdateMonitor;
typedef struct _XdpDbusFlatpakUpdateMonitorIface XdpDbusFlatpakUpdateMonitorIface;

struct _XdpDbusFlatpakUpdateMonitorIface
{
  GTypeInterface parent_iface;


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

  gboolean (*handle_update) (
    XdpDbusFlatpakUpdateMonitor *object,
    GDBusMethodInvocation *invocation,
    const gchar *arg_parent_window,
    GVariant *arg_options);

  void (*progress) (
    XdpDbusFlatpakUpdateMonitor *object,
    GVariant *arg_info);

  void (*update_available) (
    XdpDbusFlatpakUpdateMonitor *object,
    GVariant *arg_update_info);

};

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

GType xdp_dbus_flatpak_update_monitor_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_dbus_flatpak_update_monitor_interface_info (void);
guint xdp_dbus_flatpak_update_monitor_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_dbus_flatpak_update_monitor_complete_update (
    XdpDbusFlatpakUpdateMonitor *object,
    GDBusMethodInvocation *invocation);



/* D-Bus signal emissions functions: */
void xdp_dbus_flatpak_update_monitor_emit_update_available (
    XdpDbusFlatpakUpdateMonitor *object,
    GVariant *arg_update_info);

void xdp_dbus_flatpak_update_monitor_emit_progress (
    XdpDbusFlatpakUpdateMonitor *object,
    GVariant *arg_info);



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

gboolean xdp_dbus_flatpak_update_monitor_call_close_finish (
    XdpDbusFlatpakUpdateMonitor *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_flatpak_update_monitor_call_close_sync (
    XdpDbusFlatpakUpdateMonitor *proxy,
    GCancellable *cancellable,
    GError **error);

void xdp_dbus_flatpak_update_monitor_call_update (
    XdpDbusFlatpakUpdateMonitor *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data);

gboolean xdp_dbus_flatpak_update_monitor_call_update_finish (
    XdpDbusFlatpakUpdateMonitor *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_dbus_flatpak_update_monitor_call_update_sync (
    XdpDbusFlatpakUpdateMonitor *proxy,
    const gchar *arg_parent_window,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR_PROXY (xdp_dbus_flatpak_update_monitor_proxy_get_type ())
#define XDP_DBUS_FLATPAK_UPDATE_MONITOR_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR_PROXY, XdpDbusFlatpakUpdateMonitorProxy))
#define XDP_DBUS_FLATPAK_UPDATE_MONITOR_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR_PROXY, XdpDbusFlatpakUpdateMonitorProxyClass))
#define XDP_DBUS_FLATPAK_UPDATE_MONITOR_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR_PROXY, XdpDbusFlatpakUpdateMonitorProxyClass))
#define XDP_DBUS_IS_FLATPAK_UPDATE_MONITOR_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR_PROXY))
#define XDP_DBUS_IS_FLATPAK_UPDATE_MONITOR_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR_PROXY))

typedef struct _XdpDbusFlatpakUpdateMonitorProxy XdpDbusFlatpakUpdateMonitorProxy;
typedef struct _XdpDbusFlatpakUpdateMonitorProxyClass XdpDbusFlatpakUpdateMonitorProxyClass;
typedef struct _XdpDbusFlatpakUpdateMonitorProxyPrivate XdpDbusFlatpakUpdateMonitorProxyPrivate;

struct _XdpDbusFlatpakUpdateMonitorProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpDbusFlatpakUpdateMonitorProxyPrivate *priv;
};

struct _XdpDbusFlatpakUpdateMonitorProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_dbus_flatpak_update_monitor_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_dbus_flatpak_update_monitor_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusFlatpakUpdateMonitor *xdp_dbus_flatpak_update_monitor_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusFlatpakUpdateMonitor *xdp_dbus_flatpak_update_monitor_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_dbus_flatpak_update_monitor_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpDbusFlatpakUpdateMonitor *xdp_dbus_flatpak_update_monitor_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpDbusFlatpakUpdateMonitor *xdp_dbus_flatpak_update_monitor_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR_SKELETON (xdp_dbus_flatpak_update_monitor_skeleton_get_type ())
#define XDP_DBUS_FLATPAK_UPDATE_MONITOR_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR_SKELETON, XdpDbusFlatpakUpdateMonitorSkeleton))
#define XDP_DBUS_FLATPAK_UPDATE_MONITOR_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR_SKELETON, XdpDbusFlatpakUpdateMonitorSkeletonClass))
#define XDP_DBUS_FLATPAK_UPDATE_MONITOR_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR_SKELETON, XdpDbusFlatpakUpdateMonitorSkeletonClass))
#define XDP_DBUS_IS_FLATPAK_UPDATE_MONITOR_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR_SKELETON))
#define XDP_DBUS_IS_FLATPAK_UPDATE_MONITOR_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_DBUS_TYPE_FLATPAK_UPDATE_MONITOR_SKELETON))

typedef struct _XdpDbusFlatpakUpdateMonitorSkeleton XdpDbusFlatpakUpdateMonitorSkeleton;
typedef struct _XdpDbusFlatpakUpdateMonitorSkeletonClass XdpDbusFlatpakUpdateMonitorSkeletonClass;
typedef struct _XdpDbusFlatpakUpdateMonitorSkeletonPrivate XdpDbusFlatpakUpdateMonitorSkeletonPrivate;

struct _XdpDbusFlatpakUpdateMonitorSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpDbusFlatpakUpdateMonitorSkeletonPrivate *priv;
};

struct _XdpDbusFlatpakUpdateMonitorSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_dbus_flatpak_update_monitor_skeleton_get_type (void) G_GNUC_CONST;

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

XdpDbusFlatpakUpdateMonitor *xdp_dbus_flatpak_update_monitor_skeleton_new (void);


G_END_DECLS

#endif /* __XDP_DBUS_H__ */
