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

#ifndef __XDG_DESKTOP_PORTAL_DBUS_H__
#define __XDG_DESKTOP_PORTAL_DBUS_H__

#include <gio/gio.h>

G_BEGIN_DECLS


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

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

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

struct _XdpImplScreenshotIface
{
  GTypeInterface parent_iface;


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

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

  guint  (*get_version) (XdpImplScreenshot *object);

};

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

GType xdp_impl_screenshot_get_type (void) G_GNUC_CONST;

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


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

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



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

gboolean xdp_impl_screenshot_call_screenshot_finish (
    XdpImplScreenshot *proxy,
    guint *out_response,
    GVariant **out_results,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_impl_screenshot_call_pick_color_finish (
    XdpImplScreenshot *proxy,
    guint *out_response,
    GVariant **out_results,
    GAsyncResult *res,
    GError **error);

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



/* D-Bus property accessors: */
guint xdp_impl_screenshot_get_version (XdpImplScreenshot *object);
void xdp_impl_screenshot_set_version (XdpImplScreenshot *object, guint value);


/* ---- */

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

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

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

struct _XdpImplScreenshotProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_screenshot_proxy_get_type (void) G_GNUC_CONST;

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

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

void xdp_impl_screenshot_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplScreenshot *xdp_impl_screenshot_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplScreenshot *xdp_impl_screenshot_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_IMPL_TYPE_SCREENSHOT_SKELETON (xdp_impl_screenshot_skeleton_get_type ())
#define XDP_IMPL_SCREENSHOT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SCREENSHOT_SKELETON, XdpImplScreenshotSkeleton))
#define XDP_IMPL_SCREENSHOT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_SCREENSHOT_SKELETON, XdpImplScreenshotSkeletonClass))
#define XDP_IMPL_SCREENSHOT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_SCREENSHOT_SKELETON, XdpImplScreenshotSkeletonClass))
#define XDP_IMPL_IS_SCREENSHOT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SCREENSHOT_SKELETON))
#define XDP_IMPL_IS_SCREENSHOT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_SCREENSHOT_SKELETON))

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

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

struct _XdpImplScreenshotSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_screenshot_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplScreenshot *xdp_impl_screenshot_skeleton_new (void);


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

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

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

struct _XdpImplBackgroundIface
{
  GTypeInterface parent_iface;


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

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

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

  void (*running_applications_changed) (
    XdpImplBackground *object);

};

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

GType xdp_impl_background_get_type (void) G_GNUC_CONST;

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


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

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

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



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



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

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

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

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

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

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

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

gboolean xdp_impl_background_call_enable_autostart_finish (
    XdpImplBackground *proxy,
    gboolean *out_result,
    GAsyncResult *res,
    GError **error);

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



/* ---- */

#define XDP_IMPL_TYPE_BACKGROUND_PROXY (xdp_impl_background_proxy_get_type ())
#define XDP_IMPL_BACKGROUND_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_BACKGROUND_PROXY, XdpImplBackgroundProxy))
#define XDP_IMPL_BACKGROUND_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_BACKGROUND_PROXY, XdpImplBackgroundProxyClass))
#define XDP_IMPL_BACKGROUND_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_BACKGROUND_PROXY, XdpImplBackgroundProxyClass))
#define XDP_IMPL_IS_BACKGROUND_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_BACKGROUND_PROXY))
#define XDP_IMPL_IS_BACKGROUND_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_BACKGROUND_PROXY))

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

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

struct _XdpImplBackgroundProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_background_proxy_get_type (void) G_GNUC_CONST;

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

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

void xdp_impl_background_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplBackground *xdp_impl_background_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplBackground *xdp_impl_background_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_IMPL_TYPE_BACKGROUND_SKELETON (xdp_impl_background_skeleton_get_type ())
#define XDP_IMPL_BACKGROUND_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_BACKGROUND_SKELETON, XdpImplBackgroundSkeleton))
#define XDP_IMPL_BACKGROUND_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_BACKGROUND_SKELETON, XdpImplBackgroundSkeletonClass))
#define XDP_IMPL_BACKGROUND_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_BACKGROUND_SKELETON, XdpImplBackgroundSkeletonClass))
#define XDP_IMPL_IS_BACKGROUND_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_BACKGROUND_SKELETON))
#define XDP_IMPL_IS_BACKGROUND_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_BACKGROUND_SKELETON))

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

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

struct _XdpImplBackgroundSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_background_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplBackground *xdp_impl_background_skeleton_new (void);


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

#define XDP_IMPL_TYPE_INHIBIT (xdp_impl_inhibit_get_type ())
#define XDP_IMPL_INHIBIT(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_INHIBIT, XdpImplInhibit))
#define XDP_IMPL_IS_INHIBIT(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_INHIBIT))
#define XDP_IMPL_INHIBIT_GET_IFACE(o) (G_TYPE_INSTANCE_GET_INTERFACE ((o), XDP_IMPL_TYPE_INHIBIT, XdpImplInhibitIface))

struct _XdpImplInhibit;
typedef struct _XdpImplInhibit XdpImplInhibit;
typedef struct _XdpImplInhibitIface XdpImplInhibitIface;

struct _XdpImplInhibitIface
{
  GTypeInterface parent_iface;


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

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

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

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

};

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

GType xdp_impl_inhibit_get_type (void) G_GNUC_CONST;

GDBusInterfaceInfo *xdp_impl_inhibit_interface_info (void);
guint xdp_impl_inhibit_override_properties (GObjectClass *klass, guint property_id_begin);


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

void xdp_impl_inhibit_complete_create_monitor (
    XdpImplInhibit *object,
    GDBusMethodInvocation *invocation,
    guint response);

void xdp_impl_inhibit_complete_query_end_response (
    XdpImplInhibit *object,
    GDBusMethodInvocation *invocation);



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



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

gboolean xdp_impl_inhibit_call_inhibit_finish (
    XdpImplInhibit *proxy,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_impl_inhibit_call_create_monitor_finish (
    XdpImplInhibit *proxy,
    guint *out_response,
    GAsyncResult *res,
    GError **error);

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

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

gboolean xdp_impl_inhibit_call_query_end_response_finish (
    XdpImplInhibit *proxy,
    GAsyncResult *res,
    GError **error);

gboolean xdp_impl_inhibit_call_query_end_response_sync (
    XdpImplInhibit *proxy,
    const gchar *arg_session_handle,
    GCancellable *cancellable,
    GError **error);



/* ---- */

#define XDP_IMPL_TYPE_INHIBIT_PROXY (xdp_impl_inhibit_proxy_get_type ())
#define XDP_IMPL_INHIBIT_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_INHIBIT_PROXY, XdpImplInhibitProxy))
#define XDP_IMPL_INHIBIT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_INHIBIT_PROXY, XdpImplInhibitProxyClass))
#define XDP_IMPL_INHIBIT_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_INHIBIT_PROXY, XdpImplInhibitProxyClass))
#define XDP_IMPL_IS_INHIBIT_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_INHIBIT_PROXY))
#define XDP_IMPL_IS_INHIBIT_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_INHIBIT_PROXY))

typedef struct _XdpImplInhibitProxy XdpImplInhibitProxy;
typedef struct _XdpImplInhibitProxyClass XdpImplInhibitProxyClass;
typedef struct _XdpImplInhibitProxyPrivate XdpImplInhibitProxyPrivate;

struct _XdpImplInhibitProxy
{
  /*< private >*/
  GDBusProxy parent_instance;
  XdpImplInhibitProxyPrivate *priv;
};

struct _XdpImplInhibitProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_inhibit_proxy_get_type (void) G_GNUC_CONST;

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

void xdp_impl_inhibit_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplInhibit *xdp_impl_inhibit_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplInhibit *xdp_impl_inhibit_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);

void xdp_impl_inhibit_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplInhibit *xdp_impl_inhibit_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplInhibit *xdp_impl_inhibit_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_IMPL_TYPE_INHIBIT_SKELETON (xdp_impl_inhibit_skeleton_get_type ())
#define XDP_IMPL_INHIBIT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_INHIBIT_SKELETON, XdpImplInhibitSkeleton))
#define XDP_IMPL_INHIBIT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_INHIBIT_SKELETON, XdpImplInhibitSkeletonClass))
#define XDP_IMPL_INHIBIT_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_INHIBIT_SKELETON, XdpImplInhibitSkeletonClass))
#define XDP_IMPL_IS_INHIBIT_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_INHIBIT_SKELETON))
#define XDP_IMPL_IS_INHIBIT_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_INHIBIT_SKELETON))

typedef struct _XdpImplInhibitSkeleton XdpImplInhibitSkeleton;
typedef struct _XdpImplInhibitSkeletonClass XdpImplInhibitSkeletonClass;
typedef struct _XdpImplInhibitSkeletonPrivate XdpImplInhibitSkeletonPrivate;

struct _XdpImplInhibitSkeleton
{
  /*< private >*/
  GDBusInterfaceSkeleton parent_instance;
  XdpImplInhibitSkeletonPrivate *priv;
};

struct _XdpImplInhibitSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_inhibit_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplInhibit *xdp_impl_inhibit_skeleton_new (void);


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

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

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

struct _XdpImplLockdownIface
{
  GTypeInterface parent_iface;

  gboolean  (*get_disable_application_handlers) (XdpImplLockdown *object);

  gboolean  (*get_disable_camera) (XdpImplLockdown *object);

  gboolean  (*get_disable_location) (XdpImplLockdown *object);

  gboolean  (*get_disable_microphone) (XdpImplLockdown *object);

  gboolean  (*get_disable_printing) (XdpImplLockdown *object);

  gboolean  (*get_disable_save_to_disk) (XdpImplLockdown *object);

  gboolean  (*get_disable_sound_output) (XdpImplLockdown *object);

};

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

GType xdp_impl_lockdown_get_type (void) G_GNUC_CONST;

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


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

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

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

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

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

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

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


/* ---- */

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

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

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

struct _XdpImplLockdownProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_lockdown_proxy_get_type (void) G_GNUC_CONST;

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

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

void xdp_impl_lockdown_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplLockdown *xdp_impl_lockdown_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplLockdown *xdp_impl_lockdown_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_IMPL_TYPE_LOCKDOWN_SKELETON (xdp_impl_lockdown_skeleton_get_type ())
#define XDP_IMPL_LOCKDOWN_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_LOCKDOWN_SKELETON, XdpImplLockdownSkeleton))
#define XDP_IMPL_LOCKDOWN_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_LOCKDOWN_SKELETON, XdpImplLockdownSkeletonClass))
#define XDP_IMPL_LOCKDOWN_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_LOCKDOWN_SKELETON, XdpImplLockdownSkeletonClass))
#define XDP_IMPL_IS_LOCKDOWN_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_LOCKDOWN_SKELETON))
#define XDP_IMPL_IS_LOCKDOWN_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_LOCKDOWN_SKELETON))

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

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

struct _XdpImplLockdownSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_lockdown_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplLockdown *xdp_impl_lockdown_skeleton_new (void);


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

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

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

struct _XdpImplRequestIface
{
  GTypeInterface parent_iface;

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

};

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

GType xdp_impl_request_get_type (void) G_GNUC_CONST;

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


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



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

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

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



/* ---- */

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

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

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

struct _XdpImplRequestProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_request_proxy_get_type (void) G_GNUC_CONST;

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

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

void xdp_impl_request_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplRequest *xdp_impl_request_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplRequest *xdp_impl_request_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_IMPL_TYPE_REQUEST_SKELETON (xdp_impl_request_skeleton_get_type ())
#define XDP_IMPL_REQUEST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_REQUEST_SKELETON, XdpImplRequestSkeleton))
#define XDP_IMPL_REQUEST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_REQUEST_SKELETON, XdpImplRequestSkeletonClass))
#define XDP_IMPL_REQUEST_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_REQUEST_SKELETON, XdpImplRequestSkeletonClass))
#define XDP_IMPL_IS_REQUEST_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_REQUEST_SKELETON))
#define XDP_IMPL_IS_REQUEST_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_REQUEST_SKELETON))

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

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

struct _XdpImplRequestSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_request_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplRequest *xdp_impl_request_skeleton_new (void);


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

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

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

struct _XdpImplSessionIface
{
  GTypeInterface parent_iface;



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

  guint  (*get_version) (XdpImplSession *object);

  void (*closed) (
    XdpImplSession *object);

};

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

GType xdp_impl_session_get_type (void) G_GNUC_CONST;

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


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



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



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

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

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



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


/* ---- */

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

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

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

struct _XdpImplSessionProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_session_proxy_get_type (void) G_GNUC_CONST;

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

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

void xdp_impl_session_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplSession *xdp_impl_session_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplSession *xdp_impl_session_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_IMPL_TYPE_SESSION_SKELETON (xdp_impl_session_skeleton_get_type ())
#define XDP_IMPL_SESSION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SESSION_SKELETON, XdpImplSessionSkeleton))
#define XDP_IMPL_SESSION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_SESSION_SKELETON, XdpImplSessionSkeletonClass))
#define XDP_IMPL_SESSION_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_SESSION_SKELETON, XdpImplSessionSkeletonClass))
#define XDP_IMPL_IS_SESSION_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SESSION_SKELETON))
#define XDP_IMPL_IS_SESSION_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_SESSION_SKELETON))

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

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

struct _XdpImplSessionSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_session_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplSession *xdp_impl_session_skeleton_new (void);


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

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

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

struct _XdpImplSettingsIface
{
  GTypeInterface parent_iface;



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

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

  guint  (*get_version) (XdpImplSettings *object);

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

};

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

GType xdp_impl_settings_get_type (void) G_GNUC_CONST;

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


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

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



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



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

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

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

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

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

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



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


/* ---- */

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

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

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

struct _XdpImplSettingsProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_settings_proxy_get_type (void) G_GNUC_CONST;

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

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

void xdp_impl_settings_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplSettings *xdp_impl_settings_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplSettings *xdp_impl_settings_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_IMPL_TYPE_SETTINGS_SKELETON (xdp_impl_settings_skeleton_get_type ())
#define XDP_IMPL_SETTINGS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_SETTINGS_SKELETON, XdpImplSettingsSkeleton))
#define XDP_IMPL_SETTINGS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_SETTINGS_SKELETON, XdpImplSettingsSkeletonClass))
#define XDP_IMPL_SETTINGS_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_SETTINGS_SKELETON, XdpImplSettingsSkeletonClass))
#define XDP_IMPL_IS_SETTINGS_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_SETTINGS_SKELETON))
#define XDP_IMPL_IS_SETTINGS_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_SETTINGS_SKELETON))

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

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

struct _XdpImplSettingsSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_settings_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplSettings *xdp_impl_settings_skeleton_new (void);


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

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

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

struct _XdpImplWallpaperIface
{
  GTypeInterface parent_iface;

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

};

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

GType xdp_impl_wallpaper_get_type (void) G_GNUC_CONST;

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


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



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

gboolean xdp_impl_wallpaper_call_set_wallpaper_uri_finish (
    XdpImplWallpaper *proxy,
    guint *out_response,
    GAsyncResult *res,
    GError **error);

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



/* ---- */

#define XDP_IMPL_TYPE_WALLPAPER_PROXY (xdp_impl_wallpaper_proxy_get_type ())
#define XDP_IMPL_WALLPAPER_PROXY(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_WALLPAPER_PROXY, XdpImplWallpaperProxy))
#define XDP_IMPL_WALLPAPER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_WALLPAPER_PROXY, XdpImplWallpaperProxyClass))
#define XDP_IMPL_WALLPAPER_PROXY_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_WALLPAPER_PROXY, XdpImplWallpaperProxyClass))
#define XDP_IMPL_IS_WALLPAPER_PROXY(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_WALLPAPER_PROXY))
#define XDP_IMPL_IS_WALLPAPER_PROXY_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_WALLPAPER_PROXY))

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

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

struct _XdpImplWallpaperProxyClass
{
  GDBusProxyClass parent_class;
};

GType xdp_impl_wallpaper_proxy_get_type (void) G_GNUC_CONST;

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

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

void xdp_impl_wallpaper_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data);
XdpImplWallpaper *xdp_impl_wallpaper_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error);
XdpImplWallpaper *xdp_impl_wallpaper_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error);


/* ---- */

#define XDP_IMPL_TYPE_WALLPAPER_SKELETON (xdp_impl_wallpaper_skeleton_get_type ())
#define XDP_IMPL_WALLPAPER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_CAST ((o), XDP_IMPL_TYPE_WALLPAPER_SKELETON, XdpImplWallpaperSkeleton))
#define XDP_IMPL_WALLPAPER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_CAST ((k), XDP_IMPL_TYPE_WALLPAPER_SKELETON, XdpImplWallpaperSkeletonClass))
#define XDP_IMPL_WALLPAPER_SKELETON_GET_CLASS(o) (G_TYPE_INSTANCE_GET_CLASS ((o), XDP_IMPL_TYPE_WALLPAPER_SKELETON, XdpImplWallpaperSkeletonClass))
#define XDP_IMPL_IS_WALLPAPER_SKELETON(o) (G_TYPE_CHECK_INSTANCE_TYPE ((o), XDP_IMPL_TYPE_WALLPAPER_SKELETON))
#define XDP_IMPL_IS_WALLPAPER_SKELETON_CLASS(k) (G_TYPE_CHECK_CLASS_TYPE ((k), XDP_IMPL_TYPE_WALLPAPER_SKELETON))

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

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

struct _XdpImplWallpaperSkeletonClass
{
  GDBusInterfaceSkeletonClass parent_class;
};

GType xdp_impl_wallpaper_skeleton_get_type (void) G_GNUC_CONST;

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

XdpImplWallpaper *xdp_impl_wallpaper_skeleton_new (void);


G_END_DECLS

#endif /* __XDG_DESKTOP_PORTAL_DBUS_H__ */
