/*
 * 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.
 */

#ifdef HAVE_CONFIG_H
#  include "config.h"
#endif

#include "udisks-generated.h"

#include <string.h>
#ifdef G_OS_UNIX
#  include <gio/gunixfdlist.h>
#endif

#ifdef G_ENABLE_DEBUG
#define g_marshal_value_peek_boolean(v)  g_value_get_boolean (v)
#define g_marshal_value_peek_char(v)     g_value_get_schar (v)
#define g_marshal_value_peek_uchar(v)    g_value_get_uchar (v)
#define g_marshal_value_peek_int(v)      g_value_get_int (v)
#define g_marshal_value_peek_uint(v)     g_value_get_uint (v)
#define g_marshal_value_peek_long(v)     g_value_get_long (v)
#define g_marshal_value_peek_ulong(v)    g_value_get_ulong (v)
#define g_marshal_value_peek_int64(v)    g_value_get_int64 (v)
#define g_marshal_value_peek_uint64(v)   g_value_get_uint64 (v)
#define g_marshal_value_peek_enum(v)     g_value_get_enum (v)
#define g_marshal_value_peek_flags(v)    g_value_get_flags (v)
#define g_marshal_value_peek_float(v)    g_value_get_float (v)
#define g_marshal_value_peek_double(v)   g_value_get_double (v)
#define g_marshal_value_peek_string(v)   (char*) g_value_get_string (v)
#define g_marshal_value_peek_param(v)    g_value_get_param (v)
#define g_marshal_value_peek_boxed(v)    g_value_get_boxed (v)
#define g_marshal_value_peek_pointer(v)  g_value_get_pointer (v)
#define g_marshal_value_peek_object(v)   g_value_get_object (v)
#define g_marshal_value_peek_variant(v)  g_value_get_variant (v)
#else /* !G_ENABLE_DEBUG */
/* WARNING: This code accesses GValues directly, which is UNSUPPORTED API.
 *          Do not access GValues directly in your code. Instead, use the
 *          g_value_get_*() functions
 */
#define g_marshal_value_peek_boolean(v)  (v)->data[0].v_int
#define g_marshal_value_peek_char(v)     (v)->data[0].v_int
#define g_marshal_value_peek_uchar(v)    (v)->data[0].v_uint
#define g_marshal_value_peek_int(v)      (v)->data[0].v_int
#define g_marshal_value_peek_uint(v)     (v)->data[0].v_uint
#define g_marshal_value_peek_long(v)     (v)->data[0].v_long
#define g_marshal_value_peek_ulong(v)    (v)->data[0].v_ulong
#define g_marshal_value_peek_int64(v)    (v)->data[0].v_int64
#define g_marshal_value_peek_uint64(v)   (v)->data[0].v_uint64
#define g_marshal_value_peek_enum(v)     (v)->data[0].v_long
#define g_marshal_value_peek_flags(v)    (v)->data[0].v_ulong
#define g_marshal_value_peek_float(v)    (v)->data[0].v_float
#define g_marshal_value_peek_double(v)   (v)->data[0].v_double
#define g_marshal_value_peek_string(v)   (v)->data[0].v_pointer
#define g_marshal_value_peek_param(v)    (v)->data[0].v_pointer
#define g_marshal_value_peek_boxed(v)    (v)->data[0].v_pointer
#define g_marshal_value_peek_pointer(v)  (v)->data[0].v_pointer
#define g_marshal_value_peek_object(v)   (v)->data[0].v_pointer
#define g_marshal_value_peek_variant(v)  (v)->data[0].v_pointer
#endif /* !G_ENABLE_DEBUG */

typedef struct
{
  GDBusArgInfo parent_struct;
  gboolean use_gvariant;
} _ExtendedGDBusArgInfo;

typedef struct
{
  GDBusMethodInfo parent_struct;
  const gchar *signal_name;
  gboolean pass_fdlist;
} _ExtendedGDBusMethodInfo;

typedef struct
{
  GDBusSignalInfo parent_struct;
  const gchar *signal_name;
} _ExtendedGDBusSignalInfo;

typedef struct
{
  GDBusPropertyInfo parent_struct;
  const gchar *hyphen_name;
  guint use_gvariant : 1;
  guint emits_changed_signal : 1;
} _ExtendedGDBusPropertyInfo;

typedef struct
{
  GDBusInterfaceInfo parent_struct;
  const gchar *hyphen_name;
} _ExtendedGDBusInterfaceInfo;

typedef struct
{
  const _ExtendedGDBusPropertyInfo *info;
  guint prop_id;
  GValue orig_value; /* the value before the change */
} ChangedProperty;

static void
_changed_property_free (ChangedProperty *data)
{
  g_value_unset (&data->orig_value);
  g_free (data);
}

static gboolean
_g_strv_equal0 (gchar **a, gchar **b)
{
  gboolean ret = FALSE;
  guint n;
  if (a == NULL && b == NULL)
    {
      ret = TRUE;
      goto out;
    }
  if (a == NULL || b == NULL)
    goto out;
  if (g_strv_length (a) != g_strv_length (b))
    goto out;
  for (n = 0; a[n] != NULL; n++)
    if (g_strcmp0 (a[n], b[n]) != 0)
      goto out;
  ret = TRUE;
out:
  return ret;
}

static gboolean
_g_variant_equal0 (GVariant *a, GVariant *b)
{
  gboolean ret = FALSE;
  if (a == NULL && b == NULL)
    {
      ret = TRUE;
      goto out;
    }
  if (a == NULL || b == NULL)
    goto out;
  ret = g_variant_equal (a, b);
out:
  return ret;
}

G_GNUC_UNUSED static gboolean
_g_value_equal (const GValue *a, const GValue *b)
{
  gboolean ret = FALSE;
  g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b));
  switch (G_VALUE_TYPE (a))
    {
      case G_TYPE_BOOLEAN:
        ret = (g_value_get_boolean (a) == g_value_get_boolean (b));
        break;
      case G_TYPE_UCHAR:
        ret = (g_value_get_uchar (a) == g_value_get_uchar (b));
        break;
      case G_TYPE_INT:
        ret = (g_value_get_int (a) == g_value_get_int (b));
        break;
      case G_TYPE_UINT:
        ret = (g_value_get_uint (a) == g_value_get_uint (b));
        break;
      case G_TYPE_INT64:
        ret = (g_value_get_int64 (a) == g_value_get_int64 (b));
        break;
      case G_TYPE_UINT64:
        ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b));
        break;
      case G_TYPE_DOUBLE:
        {
          /* Avoid -Wfloat-equal warnings by doing a direct bit compare */
          gdouble da = g_value_get_double (a);
          gdouble db = g_value_get_double (b);
          ret = memcmp (&da, &db, sizeof (gdouble)) == 0;
        }
        break;
      case G_TYPE_STRING:
        ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0);
        break;
      case G_TYPE_VARIANT:
        ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b));
        break;
      default:
        if (G_VALUE_TYPE (a) == G_TYPE_STRV)
          ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b));
        else
          g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a)));
        break;
    }
  return ret;
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectStringFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *arg_type,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectStringFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 3);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectStringFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_string (param_values + 2),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_OBJECT_VARIANT_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectObjectVariantVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        GUnixFDList *arg_fd_list,
        GVariant *arg_fd,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectObjectVariantVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 5);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectObjectVariantVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_object (param_values + 2),
              g_marshal_value_peek_variant (param_values + 3),
              g_marshal_value_peek_variant (param_values + 4),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOXED_STRING_STRING_UINT64_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectBoxedStringStringUint64VariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *const *arg_blocks,
        const gchar *arg_level,
        const gchar *arg_name,
        guint64 arg_chunk,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectBoxedStringStringUint64VariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 7);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectBoxedStringStringUint64VariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_boxed (param_values + 2),
              g_marshal_value_peek_string (param_values + 3),
              g_marshal_value_peek_string (param_values + 4),
              g_marshal_value_peek_uint64 (param_values + 5),
              g_marshal_value_peek_variant (param_values + 6),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOOLEAN (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectBooleanFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        gboolean arg_enable,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectBooleanFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 3);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectBooleanFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_boolean (param_values + 2),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_BOOLEAN (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectStringBooleanFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *arg_name,
        gboolean arg_enable,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectStringBooleanFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 4);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectStringBooleanFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_string (param_values + 2),
              g_marshal_value_peek_boolean (param_values + 3),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 3);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_variant (param_values + 2),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectVariantVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        GVariant *arg_devspec,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectVariantVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 4);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectVariantVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_variant (param_values + 2),
              g_marshal_value_peek_variant (param_values + 3),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectStringVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *arg_hostnqn,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectStringVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 4);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectStringVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_string (param_values + 2),
              g_marshal_value_peek_variant (param_values + 3),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_STRING_STRING_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectStringStringStringVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *arg_subsysnqn,
        const gchar *arg_transport,
        const gchar *arg_transport_addr,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectStringStringStringVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 6);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectStringStringStringVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_string (param_values + 2),
              g_marshal_value_peek_string (param_values + 3),
              g_marshal_value_peek_string (param_values + 4),
              g_marshal_value_peek_variant (param_values + 5),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOOLEAN_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectBooleanVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        gboolean arg_value,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectBooleanVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 4);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectBooleanVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_boolean (param_values + 2),
              g_marshal_value_peek_variant (param_values + 3),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT_VARIANT_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectVariantVariantVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        GVariant *arg_old_item,
        GVariant *arg_new_item,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectVariantVariantVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 5);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectVariantVariantVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_variant (param_values + 2),
              g_marshal_value_peek_variant (param_values + 3),
              g_marshal_value_peek_variant (param_values + 4),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_OBJECT_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectObjectVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        GUnixFDList *arg_fd_list,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectObjectVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 4);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectObjectVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_object (param_values + 2),
              g_marshal_value_peek_variant (param_values + 3),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_OBJECT_STRING_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectObjectStringVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        GUnixFDList *arg_fd_list,
        const gchar *arg_mode,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectObjectStringVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 5);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectObjectStringVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_object (param_values + 2),
              g_marshal_value_peek_string (param_values + 3),
              g_marshal_value_peek_variant (param_values + 4),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT64_UINT64_STRING_STRING_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectUint64Uint64StringStringVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        guint64 arg_offset,
        guint64 arg_size,
        const gchar *arg_type,
        const gchar *arg_name,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectUint64Uint64StringStringVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 7);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectUint64Uint64StringStringVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_uint64 (param_values + 2),
              g_marshal_value_peek_uint64 (param_values + 3),
              g_marshal_value_peek_string (param_values + 4),
              g_marshal_value_peek_string (param_values + 5),
              g_marshal_value_peek_variant (param_values + 6),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT64_UINT64_STRING_STRING_VARIANT_STRING_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectUint64Uint64StringStringVariantStringVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        guint64 arg_offset,
        guint64 arg_size,
        const gchar *arg_type,
        const gchar *arg_name,
        GVariant *arg_options,
        const gchar *arg_format_type,
        GVariant *arg_format_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectUint64Uint64StringStringVariantStringVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 9);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectUint64Uint64StringStringVariantStringVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_uint64 (param_values + 2),
              g_marshal_value_peek_uint64 (param_values + 3),
              g_marshal_value_peek_string (param_values + 4),
              g_marshal_value_peek_string (param_values + 5),
              g_marshal_value_peek_variant (param_values + 6),
              g_marshal_value_peek_string (param_values + 7),
              g_marshal_value_peek_variant (param_values + 8),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT64_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectUint64VariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        guint64 arg_flags,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectUint64VariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 4);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectUint64VariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_uint64 (param_values + 2),
              g_marshal_value_peek_variant (param_values + 3),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_STRING_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectStringStringVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *arg_passphrase,
        const gchar *arg_new_passphrase,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectStringStringVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 5);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectStringStringVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_string (param_values + 2),
              g_marshal_value_peek_string (param_values + 3),
              g_marshal_value_peek_variant (param_values + 4),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_VOID__BOOLEAN_STRING (
    GClosure     *closure,
    GValue       *return_value G_GNUC_UNUSED,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef void (*_GDbusCodegenMarshalVoid_BooleanStringFunc)
       (void *data1,
        gboolean arg_success,
        const gchar *arg_message,
        void *data2);
  _GDbusCodegenMarshalVoid_BooleanStringFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;

  g_return_if_fail (n_param_values == 3);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalVoid_BooleanStringFunc)
    (marshal_data ? marshal_data : cc->callback);

  callback (data1,
            g_marshal_value_peek_boolean (param_values + 1),
            g_marshal_value_peek_string (param_values + 2),
            data2);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOXED_STRING_STRING_STRING_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectBoxedStringStringStringVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *const *arg_devices,
        const gchar *arg_label,
        const gchar *arg_data_level,
        const gchar *arg_md_level,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectBoxedStringStringStringVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 7);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectBoxedStringStringStringVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_boxed (param_values + 2),
              g_marshal_value_peek_string (param_values + 3),
              g_marshal_value_peek_string (param_values + 4),
              g_marshal_value_peek_string (param_values + 5),
              g_marshal_value_peek_variant (param_values + 6),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_STRING_BOOLEAN_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectStringStringBooleanVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *arg_source,
        const gchar *arg_dest,
        gboolean arg_ro,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectStringStringBooleanVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 6);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectStringStringBooleanVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_string (param_values + 2),
              g_marshal_value_peek_string (param_values + 3),
              g_marshal_value_peek_boolean (param_values + 4),
              g_marshal_value_peek_variant (param_values + 5),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectUintVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        guint arg_id,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectUintVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 4);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectUintVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_uint (param_values + 2),
              g_marshal_value_peek_variant (param_values + 3),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_BOXED_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectStringBoxedVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *arg_name,
        const gchar *const *arg_blocks,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectStringBoxedVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 5);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectStringBoxedVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_string (param_values + 2),
              g_marshal_value_peek_boxed (param_values + 3),
              g_marshal_value_peek_variant (param_values + 4),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 2);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_BOOLEAN_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectStringBooleanVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *arg_block,
        gboolean arg_wipe,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectStringBooleanVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 5);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectStringBooleanVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_string (param_values + 2),
              g_marshal_value_peek_boolean (param_values + 3),
              g_marshal_value_peek_variant (param_values + 4),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_UINT64_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectStringUint64VariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *arg_name,
        guint64 arg_size,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectStringUint64VariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 5);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectStringUint64VariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_string (param_values + 2),
              g_marshal_value_peek_uint64 (param_values + 3),
              g_marshal_value_peek_variant (param_values + 4),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_UINT64_STRING_BOXED_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectStringUint64StringBoxedVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *arg_name,
        guint64 arg_size,
        const gchar *arg_layout,
        const gchar *const *arg_pvs,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectStringUint64StringBoxedVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 7);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectStringUint64StringBoxedVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_string (param_values + 2),
              g_marshal_value_peek_uint64 (param_values + 3),
              g_marshal_value_peek_string (param_values + 4),
              g_marshal_value_peek_boxed (param_values + 5),
              g_marshal_value_peek_variant (param_values + 6),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_UINT64_STRING_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectStringUint64StringVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *arg_name,
        guint64 arg_size,
        const gchar *arg_pool,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectStringUint64StringVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 6);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectStringUint64StringVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_string (param_values + 2),
              g_marshal_value_peek_uint64 (param_values + 3),
              g_marshal_value_peek_string (param_values + 4),
              g_marshal_value_peek_variant (param_values + 5),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_STRING_UINT64_UINT64_UINT64_BOOLEAN_BOOLEAN_STRING_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectStringStringUint64Uint64Uint64BooleanBooleanStringVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *arg_lv_name,
        const gchar *arg_pool_name,
        guint64 arg_data_size,
        guint64 arg_virtual_size,
        guint64 arg_index_memory,
        gboolean arg_compression,
        gboolean arg_deduplication,
        const gchar *arg_write_policy,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectStringStringUint64Uint64Uint64BooleanBooleanStringVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 11);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectStringStringUint64Uint64Uint64BooleanBooleanStringVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_string (param_values + 2),
              g_marshal_value_peek_string (param_values + 3),
              g_marshal_value_peek_uint64 (param_values + 4),
              g_marshal_value_peek_uint64 (param_values + 5),
              g_marshal_value_peek_uint64 (param_values + 6),
              g_marshal_value_peek_boolean (param_values + 7),
              g_marshal_value_peek_boolean (param_values + 8),
              g_marshal_value_peek_string (param_values + 9),
              g_marshal_value_peek_variant (param_values + 10),
              data2);

  g_value_set_boolean (return_value, v_return);
}

static void
_g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOXED_VARIANT (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint G_GNUC_UNUSED,
    void         *marshal_data)
{
  typedef gboolean (*_GDbusCodegenMarshalBoolean_ObjectBoxedVariantFunc)
       (void *data1,
        GDBusMethodInvocation *arg_method_invocation,
        const gchar *const *arg_pvs,
        GVariant *arg_options,
        void *data2);
  _GDbusCodegenMarshalBoolean_ObjectBoxedVariantFunc callback;
  GCClosure *cc = (GCClosure*) closure;
  void *data1, *data2;
  gboolean v_return;

  g_return_if_fail (return_value != NULL);
  g_return_if_fail (n_param_values == 4);

  if (G_CCLOSURE_SWAP_DATA (closure))
    {
      data1 = closure->data;
      data2 = g_value_peek_pointer (param_values + 0);
    }
  else
    {
      data1 = g_value_peek_pointer (param_values + 0);
      data2 = closure->data;
    }

  callback = (_GDbusCodegenMarshalBoolean_ObjectBoxedVariantFunc)
    (marshal_data ? marshal_data : cc->callback);

  v_return =
    callback (data1,
              g_marshal_value_peek_object (param_values + 1),
              g_marshal_value_peek_boxed (param_values + 2),
              g_marshal_value_peek_variant (param_values + 3),
              data2);

  g_value_set_boolean (return_value, v_return);
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Manager
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksManager
 * @title: UDisksManager
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Manager D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager.top_of_page">org.freedesktop.UDisks2.Manager</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Manager ---- */

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_can_format_IN_ARG_type =
{
  {
    -1,
    (gchar *) "type",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_can_format_IN_ARG_pointers[] =
{
  &_udisks_manager_method_info_can_format_IN_ARG_type.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_can_format_OUT_ARG_available =
{
  {
    -1,
    (gchar *) "available",
    (gchar *) "(bs)",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_can_format_OUT_ARG_pointers[] =
{
  &_udisks_manager_method_info_can_format_OUT_ARG_available.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_method_info_can_format =
{
  {
    -1,
    (gchar *) "CanFormat",
    (GDBusArgInfo **) &_udisks_manager_method_info_can_format_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_manager_method_info_can_format_OUT_ARG_pointers,
    NULL
  },
  "handle-can-format",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_can_resize_IN_ARG_type =
{
  {
    -1,
    (gchar *) "type",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_can_resize_IN_ARG_pointers[] =
{
  &_udisks_manager_method_info_can_resize_IN_ARG_type.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_can_resize_OUT_ARG_available =
{
  {
    -1,
    (gchar *) "available",
    (gchar *) "(bts)",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_can_resize_OUT_ARG_pointers[] =
{
  &_udisks_manager_method_info_can_resize_OUT_ARG_available.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_method_info_can_resize =
{
  {
    -1,
    (gchar *) "CanResize",
    (GDBusArgInfo **) &_udisks_manager_method_info_can_resize_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_manager_method_info_can_resize_OUT_ARG_pointers,
    NULL
  },
  "handle-can-resize",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_can_check_IN_ARG_type =
{
  {
    -1,
    (gchar *) "type",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_can_check_IN_ARG_pointers[] =
{
  &_udisks_manager_method_info_can_check_IN_ARG_type.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_can_check_OUT_ARG_available =
{
  {
    -1,
    (gchar *) "available",
    (gchar *) "(bs)",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_can_check_OUT_ARG_pointers[] =
{
  &_udisks_manager_method_info_can_check_OUT_ARG_available.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_method_info_can_check =
{
  {
    -1,
    (gchar *) "CanCheck",
    (GDBusArgInfo **) &_udisks_manager_method_info_can_check_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_manager_method_info_can_check_OUT_ARG_pointers,
    NULL
  },
  "handle-can-check",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_can_repair_IN_ARG_type =
{
  {
    -1,
    (gchar *) "type",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_can_repair_IN_ARG_pointers[] =
{
  &_udisks_manager_method_info_can_repair_IN_ARG_type.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_can_repair_OUT_ARG_available =
{
  {
    -1,
    (gchar *) "available",
    (gchar *) "(bs)",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_can_repair_OUT_ARG_pointers[] =
{
  &_udisks_manager_method_info_can_repair_OUT_ARG_available.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_method_info_can_repair =
{
  {
    -1,
    (gchar *) "CanRepair",
    (GDBusArgInfo **) &_udisks_manager_method_info_can_repair_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_manager_method_info_can_repair_OUT_ARG_pointers,
    NULL
  },
  "handle-can-repair",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_loop_setup_IN_ARG_fd =
{
  {
    -1,
    (gchar *) "fd",
    (gchar *) "h",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_loop_setup_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_loop_setup_IN_ARG_pointers[] =
{
  &_udisks_manager_method_info_loop_setup_IN_ARG_fd.parent_struct,
  &_udisks_manager_method_info_loop_setup_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_loop_setup_OUT_ARG_resulting_device =
{
  {
    -1,
    (gchar *) "resulting_device",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_loop_setup_OUT_ARG_pointers[] =
{
  &_udisks_manager_method_info_loop_setup_OUT_ARG_resulting_device.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_method_info_loop_setup =
{
  {
    -1,
    (gchar *) "LoopSetup",
    (GDBusArgInfo **) &_udisks_manager_method_info_loop_setup_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_manager_method_info_loop_setup_OUT_ARG_pointers,
    NULL
  },
  "handle-loop-setup",
  TRUE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_mdraid_create_IN_ARG_blocks =
{
  {
    -1,
    (gchar *) "blocks",
    (gchar *) "ao",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_mdraid_create_IN_ARG_level =
{
  {
    -1,
    (gchar *) "level",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_mdraid_create_IN_ARG_name =
{
  {
    -1,
    (gchar *) "name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_mdraid_create_IN_ARG_chunk =
{
  {
    -1,
    (gchar *) "chunk",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_mdraid_create_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_mdraid_create_IN_ARG_pointers[] =
{
  &_udisks_manager_method_info_mdraid_create_IN_ARG_blocks.parent_struct,
  &_udisks_manager_method_info_mdraid_create_IN_ARG_level.parent_struct,
  &_udisks_manager_method_info_mdraid_create_IN_ARG_name.parent_struct,
  &_udisks_manager_method_info_mdraid_create_IN_ARG_chunk.parent_struct,
  &_udisks_manager_method_info_mdraid_create_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_mdraid_create_OUT_ARG_resulting_array =
{
  {
    -1,
    (gchar *) "resulting_array",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_mdraid_create_OUT_ARG_pointers[] =
{
  &_udisks_manager_method_info_mdraid_create_OUT_ARG_resulting_array.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_method_info_mdraid_create =
{
  {
    -1,
    (gchar *) "MDRaidCreate",
    (GDBusArgInfo **) &_udisks_manager_method_info_mdraid_create_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_manager_method_info_mdraid_create_OUT_ARG_pointers,
    NULL
  },
  "handle-mdraid-create",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_enable_modules_IN_ARG_enable =
{
  {
    -1,
    (gchar *) "enable",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_enable_modules_IN_ARG_pointers[] =
{
  &_udisks_manager_method_info_enable_modules_IN_ARG_enable.parent_struct,
  NULL
};

static const GDBusAnnotationInfo _udisks_manager_method_enable_modules_annotation_info_0 =
{
  -1,
  (gchar *) "org.freedesktop.DBus.Deprecated",
  (gchar *) "true",
  NULL
};

static const GDBusAnnotationInfo * const _udisks_manager_method_enable_modules_annotation_info_pointers[] =
{
  &_udisks_manager_method_enable_modules_annotation_info_0,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_method_info_enable_modules =
{
  {
    -1,
    (gchar *) "EnableModules",
    (GDBusArgInfo **) &_udisks_manager_method_info_enable_modules_IN_ARG_pointers,
    NULL,
    (GDBusAnnotationInfo **) &_udisks_manager_method_enable_modules_annotation_info_pointers
  },
  "handle-enable-modules",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_enable_module_IN_ARG_name =
{
  {
    -1,
    (gchar *) "name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_enable_module_IN_ARG_enable =
{
  {
    -1,
    (gchar *) "enable",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_enable_module_IN_ARG_pointers[] =
{
  &_udisks_manager_method_info_enable_module_IN_ARG_name.parent_struct,
  &_udisks_manager_method_info_enable_module_IN_ARG_enable.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_method_info_enable_module =
{
  {
    -1,
    (gchar *) "EnableModule",
    (GDBusArgInfo **) &_udisks_manager_method_info_enable_module_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-enable-module",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_get_block_devices_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_get_block_devices_IN_ARG_pointers[] =
{
  &_udisks_manager_method_info_get_block_devices_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_get_block_devices_OUT_ARG_block_objects =
{
  {
    -1,
    (gchar *) "block_objects",
    (gchar *) "ao",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_get_block_devices_OUT_ARG_pointers[] =
{
  &_udisks_manager_method_info_get_block_devices_OUT_ARG_block_objects.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_method_info_get_block_devices =
{
  {
    -1,
    (gchar *) "GetBlockDevices",
    (GDBusArgInfo **) &_udisks_manager_method_info_get_block_devices_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_manager_method_info_get_block_devices_OUT_ARG_pointers,
    NULL
  },
  "handle-get-block-devices",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_get_drives_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_get_drives_IN_ARG_pointers[] =
{
  &_udisks_manager_method_info_get_drives_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_get_drives_OUT_ARG_drive_objects =
{
  {
    -1,
    (gchar *) "drive_objects",
    (gchar *) "ao",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_get_drives_OUT_ARG_pointers[] =
{
  &_udisks_manager_method_info_get_drives_OUT_ARG_drive_objects.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_method_info_get_drives =
{
  {
    -1,
    (gchar *) "GetDrives",
    (GDBusArgInfo **) &_udisks_manager_method_info_get_drives_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_manager_method_info_get_drives_OUT_ARG_pointers,
    NULL
  },
  "handle-get-drives",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_resolve_device_IN_ARG_devspec =
{
  {
    -1,
    (gchar *) "devspec",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_resolve_device_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_resolve_device_IN_ARG_pointers[] =
{
  &_udisks_manager_method_info_resolve_device_IN_ARG_devspec.parent_struct,
  &_udisks_manager_method_info_resolve_device_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_manager_method_info_resolve_device_OUT_ARG_devices =
{
  {
    -1,
    (gchar *) "devices",
    (gchar *) "ao",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_method_info_resolve_device_OUT_ARG_pointers[] =
{
  &_udisks_manager_method_info_resolve_device_OUT_ARG_devices.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_method_info_resolve_device =
{
  {
    -1,
    (gchar *) "ResolveDevice",
    (GDBusArgInfo **) &_udisks_manager_method_info_resolve_device_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_manager_method_info_resolve_device_OUT_ARG_pointers,
    NULL
  },
  "handle-resolve-device",
  FALSE
};

static const GDBusMethodInfo * const _udisks_manager_method_info_pointers[] =
{
  &_udisks_manager_method_info_can_format.parent_struct,
  &_udisks_manager_method_info_can_resize.parent_struct,
  &_udisks_manager_method_info_can_check.parent_struct,
  &_udisks_manager_method_info_can_repair.parent_struct,
  &_udisks_manager_method_info_loop_setup.parent_struct,
  &_udisks_manager_method_info_mdraid_create.parent_struct,
  &_udisks_manager_method_info_enable_modules.parent_struct,
  &_udisks_manager_method_info_enable_module.parent_struct,
  &_udisks_manager_method_info_get_block_devices.parent_struct,
  &_udisks_manager_method_info_get_drives.parent_struct,
  &_udisks_manager_method_info_resolve_device.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_manager_property_info_version =
{
  {
    -1,
    (gchar *) "Version",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "version",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_manager_property_info_supported_filesystems =
{
  {
    -1,
    (gchar *) "SupportedFilesystems",
    (gchar *) "as",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "supported-filesystems",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_manager_property_info_supported_encryption_types =
{
  {
    -1,
    (gchar *) "SupportedEncryptionTypes",
    (gchar *) "as",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "supported-encryption-types",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_manager_property_info_default_encryption_type =
{
  {
    -1,
    (gchar *) "DefaultEncryptionType",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "default-encryption-type",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_manager_property_info_pointers[] =
{
  &_udisks_manager_property_info_version.parent_struct,
  &_udisks_manager_property_info_supported_filesystems.parent_struct,
  &_udisks_manager_property_info_supported_encryption_types.parent_struct,
  &_udisks_manager_property_info_default_encryption_type.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_manager_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Manager",
    (GDBusMethodInfo **) &_udisks_manager_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_manager_property_info_pointers,
    NULL
  },
  "manager",
};


/**
 * udisks_manager_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager.top_of_page">org.freedesktop.UDisks2.Manager</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_manager_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_manager_interface_info.parent_struct;
}

/**
 * udisks_manager_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksManager interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_manager_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "version");
  g_object_class_override_property (klass, property_id_begin++, "supported-filesystems");
  g_object_class_override_property (klass, property_id_begin++, "supported-encryption-types");
  g_object_class_override_property (klass, property_id_begin++, "default-encryption-type");
  return property_id_begin - 1;
}


inline static void
udisks_manager_method_marshal_can_format (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_manager_method_marshal_can_resize (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_manager_method_marshal_can_check (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_manager_method_marshal_can_repair (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_manager_method_marshal_loop_setup (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_OBJECT_VARIANT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_manager_method_marshal_mdraid_create (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOXED_STRING_STRING_UINT64_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_manager_method_marshal_enable_modules (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOOLEAN (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_manager_method_marshal_enable_module (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_BOOLEAN (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_manager_method_marshal_get_block_devices (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_manager_method_marshal_get_drives (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_manager_method_marshal_resolve_device (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksManager:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager.top_of_page">org.freedesktop.UDisks2.Manager</link>.
 */

/**
 * UDisksManagerIface:
 * @parent_iface: The parent interface.
 * @handle_enable_modules: Handler for the #UDisksManager::handle-enable-modules signal.
 * @handle_loop_setup: Handler for the #UDisksManager::handle-loop-setup signal.
 * @get_supported_filesystems: Getter for the #UDisksManager:supported-filesystems property.
 * @get_version: Getter for the #UDisksManager:version property.
 * @handle_mdraid_create: Handler for the #UDisksManager::handle-mdraid-create signal.
 * @handle_can_check: Handler for the #UDisksManager::handle-can-check signal.
 * @handle_can_format: Handler for the #UDisksManager::handle-can-format signal.
 * @handle_can_repair: Handler for the #UDisksManager::handle-can-repair signal.
 * @handle_can_resize: Handler for the #UDisksManager::handle-can-resize signal.
 * @handle_get_block_devices: Handler for the #UDisksManager::handle-get-block-devices signal.
 * @handle_resolve_device: Handler for the #UDisksManager::handle-resolve-device signal.
 * @get_default_encryption_type: Getter for the #UDisksManager:default-encryption-type property.
 * @get_supported_encryption_types: Getter for the #UDisksManager:supported-encryption-types property.
 * @handle_enable_module: Handler for the #UDisksManager::handle-enable-module signal.
 * @handle_get_drives: Handler for the #UDisksManager::handle-get-drives signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager.top_of_page">org.freedesktop.UDisks2.Manager</link>.
 */

typedef UDisksManagerIface UDisksManagerInterface;
G_DEFINE_INTERFACE (UDisksManager, udisks_manager, G_TYPE_OBJECT)

static void
udisks_manager_default_init (UDisksManagerIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksManager::handle-can-format:
   * @object: A #UDisksManager.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_type: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanFormat">CanFormat()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_complete_can_format() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.7.2
   */
  g_signal_new ("handle-can-format",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerIface, handle_can_format),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_method_marshal_can_format,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);

  /**
   * UDisksManager::handle-can-resize:
   * @object: A #UDisksManager.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_type: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanResize">CanResize()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_complete_can_resize() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.7.2
   */
  g_signal_new ("handle-can-resize",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerIface, handle_can_resize),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_method_marshal_can_resize,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);

  /**
   * UDisksManager::handle-can-check:
   * @object: A #UDisksManager.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_type: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanCheck">CanCheck()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_complete_can_check() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.7.2
   */
  g_signal_new ("handle-can-check",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerIface, handle_can_check),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_method_marshal_can_check,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);

  /**
   * UDisksManager::handle-can-repair:
   * @object: A #UDisksManager.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_type: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanRepair">CanRepair()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_complete_can_repair() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.7.2
   */
  g_signal_new ("handle-can-repair",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerIface, handle_can_repair),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_method_marshal_can_repair,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);

  /**
   * UDisksManager::handle-loop-setup:
   * @object: A #UDisksManager.
   * @invocation: A #GDBusMethodInvocation.
   * @fd_list: (nullable): A #GUnixFDList or %NULL.
   * @arg_fd: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.LoopSetup">LoopSetup()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_complete_loop_setup() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-loop-setup",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerIface, handle_loop_setup),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_method_marshal_loop_setup,
    G_TYPE_BOOLEAN,
    4,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UNIX_FD_LIST, G_TYPE_VARIANT, G_TYPE_VARIANT);

  /**
   * UDisksManager::handle-mdraid-create:
   * @object: A #UDisksManager.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_blocks: Argument passed by remote caller.
   * @arg_level: Argument passed by remote caller.
   * @arg_name: Argument passed by remote caller.
   * @arg_chunk: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.MDRaidCreate">MDRaidCreate()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_complete_mdraid_create() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-mdraid-create",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerIface, handle_mdraid_create),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_method_marshal_mdraid_create,
    G_TYPE_BOOLEAN,
    6,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRV, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_VARIANT);

  /**
   * UDisksManager::handle-enable-modules:
   * @object: A #UDisksManager.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_enable: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.EnableModules">EnableModules()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_complete_enable_modules() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Deprecated: The D-Bus method has been deprecated.
   */
  g_signal_new ("handle-enable-modules",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerIface, handle_enable_modules),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_method_marshal_enable_modules,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_BOOLEAN);

  /**
   * UDisksManager::handle-enable-module:
   * @object: A #UDisksManager.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_name: Argument passed by remote caller.
   * @arg_enable: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.EnableModule">EnableModule()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_complete_enable_module() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.9.0
   */
  g_signal_new ("handle-enable-module",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerIface, handle_enable_module),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_method_marshal_enable_module,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_BOOLEAN);

  /**
   * UDisksManager::handle-get-block-devices:
   * @object: A #UDisksManager.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.GetBlockDevices">GetBlockDevices()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_complete_get_block_devices() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.7.2
   */
  g_signal_new ("handle-get-block-devices",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerIface, handle_get_block_devices),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_method_marshal_get_block_devices,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksManager::handle-get-drives:
   * @object: A #UDisksManager.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.GetDrives">GetDrives()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_complete_get_drives() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.11
   */
  g_signal_new ("handle-get-drives",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerIface, handle_get_drives),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_method_marshal_get_drives,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksManager::handle-resolve-device:
   * @object: A #UDisksManager.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_devspec: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.ResolveDevice">ResolveDevice()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_complete_resolve_device() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.7.3
   */
  g_signal_new ("handle-resolve-device",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerIface, handle_resolve_device),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_method_marshal_resolve_device,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksManager:version:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.Version">"Version"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("version", "Version", "Version", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksManager:supported-filesystems:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.SupportedFilesystems">"SupportedFilesystems"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boxed ("supported-filesystems", "SupportedFilesystems", "SupportedFilesystems", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksManager:supported-encryption-types:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.SupportedEncryptionTypes">"SupportedEncryptionTypes"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.8.3
   */
  g_object_interface_install_property (iface,
    g_param_spec_boxed ("supported-encryption-types", "SupportedEncryptionTypes", "SupportedEncryptionTypes", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksManager:default-encryption-type:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.DefaultEncryptionType">"DefaultEncryptionType"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.8.3
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("default-encryption-type", "DefaultEncryptionType", "DefaultEncryptionType", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_manager_get_version: (skip)
 * @object: A #UDisksManager.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.Version">"Version"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_manager_dup_version() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_manager_get_version (UDisksManager *object)
{
  g_return_val_if_fail (UDISKS_IS_MANAGER (object), NULL);

  return UDISKS_MANAGER_GET_IFACE (object)->get_version (object);
}

/**
 * udisks_manager_dup_version: (skip)
 * @object: A #UDisksManager.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.Version">"Version"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_manager_dup_version (UDisksManager *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "version", &value, NULL);
  return value;
}

/**
 * udisks_manager_set_version: (skip)
 * @object: A #UDisksManager.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.Version">"Version"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_manager_set_version (UDisksManager *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "version", value, NULL);
}

/**
 * udisks_manager_get_supported_filesystems: (skip)
 * @object: A #UDisksManager.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.SupportedFilesystems">"SupportedFilesystems"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_manager_dup_supported_filesystems() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *const *
udisks_manager_get_supported_filesystems (UDisksManager *object)
{
  g_return_val_if_fail (UDISKS_IS_MANAGER (object), NULL);

  return UDISKS_MANAGER_GET_IFACE (object)->get_supported_filesystems (object);
}

/**
 * udisks_manager_dup_supported_filesystems: (skip)
 * @object: A #UDisksManager.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.SupportedFilesystems">"SupportedFilesystems"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_strfreev().
 */
gchar **
udisks_manager_dup_supported_filesystems (UDisksManager *object)
{
  gchar **value;
  g_object_get (G_OBJECT (object), "supported-filesystems", &value, NULL);
  return value;
}

/**
 * udisks_manager_set_supported_filesystems: (skip)
 * @object: A #UDisksManager.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.SupportedFilesystems">"SupportedFilesystems"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_manager_set_supported_filesystems (UDisksManager *object, const gchar *const *value)
{
  g_object_set (G_OBJECT (object), "supported-filesystems", value, NULL);
}

/**
 * udisks_manager_get_supported_encryption_types: (skip)
 * @object: A #UDisksManager.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.SupportedEncryptionTypes">"SupportedEncryptionTypes"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_manager_dup_supported_encryption_types() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.8.3
 */
const gchar *const *
udisks_manager_get_supported_encryption_types (UDisksManager *object)
{
  g_return_val_if_fail (UDISKS_IS_MANAGER (object), NULL);

  return UDISKS_MANAGER_GET_IFACE (object)->get_supported_encryption_types (object);
}

/**
 * udisks_manager_dup_supported_encryption_types: (skip)
 * @object: A #UDisksManager.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.SupportedEncryptionTypes">"SupportedEncryptionTypes"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_strfreev().
 *
 * Since: 2.8.3
 */
gchar **
udisks_manager_dup_supported_encryption_types (UDisksManager *object)
{
  gchar **value;
  g_object_get (G_OBJECT (object), "supported-encryption-types", &value, NULL);
  return value;
}

/**
 * udisks_manager_set_supported_encryption_types: (skip)
 * @object: A #UDisksManager.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.SupportedEncryptionTypes">"SupportedEncryptionTypes"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.8.3
 */
void
udisks_manager_set_supported_encryption_types (UDisksManager *object, const gchar *const *value)
{
  g_object_set (G_OBJECT (object), "supported-encryption-types", value, NULL);
}

/**
 * udisks_manager_get_default_encryption_type: (skip)
 * @object: A #UDisksManager.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.DefaultEncryptionType">"DefaultEncryptionType"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_manager_dup_default_encryption_type() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.8.3
 */
const gchar *
udisks_manager_get_default_encryption_type (UDisksManager *object)
{
  g_return_val_if_fail (UDISKS_IS_MANAGER (object), NULL);

  return UDISKS_MANAGER_GET_IFACE (object)->get_default_encryption_type (object);
}

/**
 * udisks_manager_dup_default_encryption_type: (skip)
 * @object: A #UDisksManager.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.DefaultEncryptionType">"DefaultEncryptionType"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.8.3
 */
gchar *
udisks_manager_dup_default_encryption_type (UDisksManager *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "default-encryption-type", &value, NULL);
  return value;
}

/**
 * udisks_manager_set_default_encryption_type: (skip)
 * @object: A #UDisksManager.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager.DefaultEncryptionType">"DefaultEncryptionType"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.8.3
 */
void
udisks_manager_set_default_encryption_type (UDisksManager *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "default-encryption-type", value, NULL);
}

/**
 * udisks_manager_call_can_format:
 * @proxy: A #UDisksManagerProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanFormat">CanFormat()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_call_can_format_finish() to get the result of the operation.
 *
 * See udisks_manager_call_can_format_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.7.2
 */
void
udisks_manager_call_can_format (
    UDisksManager *proxy,
    const gchar *arg_type,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CanFormat",
    g_variant_new ("(s)",
                   arg_type),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_call_can_format_finish:
 * @proxy: A #UDisksManagerProxy.
 * @out_available: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_call_can_format().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_call_can_format().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.2
 */
gboolean
udisks_manager_call_can_format_finish (
    UDisksManager *proxy,
    GVariant ** out_available,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@(bs))",
                 out_available);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_can_format_sync:
 * @proxy: A #UDisksManagerProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @out_available: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanFormat">CanFormat()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_call_can_format() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.2
 */
gboolean
udisks_manager_call_can_format_sync (
    UDisksManager *proxy,
    const gchar *arg_type,
    GVariant ** out_available,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CanFormat",
    g_variant_new ("(s)",
                   arg_type),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@(bs))",
                 out_available);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_can_resize:
 * @proxy: A #UDisksManagerProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanResize">CanResize()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_call_can_resize_finish() to get the result of the operation.
 *
 * See udisks_manager_call_can_resize_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.7.2
 */
void
udisks_manager_call_can_resize (
    UDisksManager *proxy,
    const gchar *arg_type,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CanResize",
    g_variant_new ("(s)",
                   arg_type),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_call_can_resize_finish:
 * @proxy: A #UDisksManagerProxy.
 * @out_available: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_call_can_resize().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_call_can_resize().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.2
 */
gboolean
udisks_manager_call_can_resize_finish (
    UDisksManager *proxy,
    GVariant ** out_available,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@(bts))",
                 out_available);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_can_resize_sync:
 * @proxy: A #UDisksManagerProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @out_available: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanResize">CanResize()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_call_can_resize() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.2
 */
gboolean
udisks_manager_call_can_resize_sync (
    UDisksManager *proxy,
    const gchar *arg_type,
    GVariant ** out_available,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CanResize",
    g_variant_new ("(s)",
                   arg_type),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@(bts))",
                 out_available);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_can_check:
 * @proxy: A #UDisksManagerProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanCheck">CanCheck()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_call_can_check_finish() to get the result of the operation.
 *
 * See udisks_manager_call_can_check_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.7.2
 */
void
udisks_manager_call_can_check (
    UDisksManager *proxy,
    const gchar *arg_type,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CanCheck",
    g_variant_new ("(s)",
                   arg_type),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_call_can_check_finish:
 * @proxy: A #UDisksManagerProxy.
 * @out_available: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_call_can_check().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_call_can_check().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.2
 */
gboolean
udisks_manager_call_can_check_finish (
    UDisksManager *proxy,
    GVariant ** out_available,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@(bs))",
                 out_available);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_can_check_sync:
 * @proxy: A #UDisksManagerProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @out_available: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanCheck">CanCheck()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_call_can_check() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.2
 */
gboolean
udisks_manager_call_can_check_sync (
    UDisksManager *proxy,
    const gchar *arg_type,
    GVariant ** out_available,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CanCheck",
    g_variant_new ("(s)",
                   arg_type),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@(bs))",
                 out_available);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_can_repair:
 * @proxy: A #UDisksManagerProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanRepair">CanRepair()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_call_can_repair_finish() to get the result of the operation.
 *
 * See udisks_manager_call_can_repair_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.7.2
 */
void
udisks_manager_call_can_repair (
    UDisksManager *proxy,
    const gchar *arg_type,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CanRepair",
    g_variant_new ("(s)",
                   arg_type),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_call_can_repair_finish:
 * @proxy: A #UDisksManagerProxy.
 * @out_available: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_call_can_repair().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_call_can_repair().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.2
 */
gboolean
udisks_manager_call_can_repair_finish (
    UDisksManager *proxy,
    GVariant ** out_available,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@(bs))",
                 out_available);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_can_repair_sync:
 * @proxy: A #UDisksManagerProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @out_available: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanRepair">CanRepair()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_call_can_repair() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.2
 */
gboolean
udisks_manager_call_can_repair_sync (
    UDisksManager *proxy,
    const gchar *arg_type,
    GVariant ** out_available,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CanRepair",
    g_variant_new ("(s)",
                   arg_type),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@(bs))",
                 out_available);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_loop_setup:
 * @proxy: A #UDisksManagerProxy.
 * @arg_fd: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.LoopSetup">LoopSetup()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_call_loop_setup_finish() to get the result of the operation.
 *
 * See udisks_manager_call_loop_setup_sync() for the synchronous, blocking version of this method.
 */
void
udisks_manager_call_loop_setup (
    UDisksManager *proxy,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call_with_unix_fd_list (G_DBUS_PROXY (proxy),
    "LoopSetup",
    g_variant_new ("(@h@a{sv})",
                   arg_fd,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    fd_list,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_call_loop_setup_finish:
 * @proxy: A #UDisksManagerProxy.
 * @out_resulting_device: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @out_fd_list: (out) (optional) (nullable): Return location for a #GUnixFDList or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_call_loop_setup().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_call_loop_setup().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_manager_call_loop_setup_finish (
    UDisksManager *proxy,
    gchar ** out_resulting_device,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_with_unix_fd_list_finish (G_DBUS_PROXY (proxy), out_fd_list, res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_resulting_device);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_loop_setup_sync:
 * @proxy: A #UDisksManagerProxy.
 * @arg_fd: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @out_resulting_device: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @out_fd_list: (out) (optional) (nullable): Return location for a #GUnixFDList or %NULL.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.LoopSetup">LoopSetup()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_call_loop_setup() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_manager_call_loop_setup_sync (
    UDisksManager *proxy,
    GVariant *arg_fd,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    gchar ** out_resulting_device,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_with_unix_fd_list_sync (G_DBUS_PROXY (proxy),
    "LoopSetup",
    g_variant_new ("(@h@a{sv})",
                   arg_fd,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    fd_list,
    out_fd_list,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_resulting_device);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_mdraid_create:
 * @proxy: A #UDisksManagerProxy.
 * @arg_blocks: Argument to pass with the method invocation.
 * @arg_level: Argument to pass with the method invocation.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_chunk: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.MDRaidCreate">MDRaidCreate()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_call_mdraid_create_finish() to get the result of the operation.
 *
 * See udisks_manager_call_mdraid_create_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_manager_call_mdraid_create (
    UDisksManager *proxy,
    const gchar *const *arg_blocks,
    const gchar *arg_level,
    const gchar *arg_name,
    guint64 arg_chunk,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "MDRaidCreate",
    g_variant_new ("(^aosst@a{sv})",
                   arg_blocks,
                   arg_level,
                   arg_name,
                   arg_chunk,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_call_mdraid_create_finish:
 * @proxy: A #UDisksManagerProxy.
 * @out_resulting_array: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_call_mdraid_create().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_call_mdraid_create().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_manager_call_mdraid_create_finish (
    UDisksManager *proxy,
    gchar ** out_resulting_array,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_resulting_array);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_mdraid_create_sync:
 * @proxy: A #UDisksManagerProxy.
 * @arg_blocks: Argument to pass with the method invocation.
 * @arg_level: Argument to pass with the method invocation.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_chunk: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_resulting_array: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.MDRaidCreate">MDRaidCreate()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_call_mdraid_create() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_manager_call_mdraid_create_sync (
    UDisksManager *proxy,
    const gchar *const *arg_blocks,
    const gchar *arg_level,
    const gchar *arg_name,
    guint64 arg_chunk,
    GVariant *arg_options,
    gchar ** out_resulting_array,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "MDRaidCreate",
    g_variant_new ("(^aosst@a{sv})",
                   arg_blocks,
                   arg_level,
                   arg_name,
                   arg_chunk,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_resulting_array);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_enable_modules:
 * @proxy: A #UDisksManagerProxy.
 * @arg_enable: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.EnableModules">EnableModules()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_call_enable_modules_finish() to get the result of the operation.
 *
 * See udisks_manager_call_enable_modules_sync() for the synchronous, blocking version of this method.
 *
 * Deprecated: The D-Bus method has been deprecated.
 */
void
udisks_manager_call_enable_modules (
    UDisksManager *proxy,
    gboolean arg_enable,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "EnableModules",
    g_variant_new ("(b)",
                   arg_enable),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_call_enable_modules_finish:
 * @proxy: A #UDisksManagerProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_call_enable_modules().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_call_enable_modules().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Deprecated: The D-Bus method has been deprecated.
 */
gboolean
udisks_manager_call_enable_modules_finish (
    UDisksManager *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_enable_modules_sync:
 * @proxy: A #UDisksManagerProxy.
 * @arg_enable: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.EnableModules">EnableModules()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_call_enable_modules() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Deprecated: The D-Bus method has been deprecated.
 */
gboolean
udisks_manager_call_enable_modules_sync (
    UDisksManager *proxy,
    gboolean arg_enable,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "EnableModules",
    g_variant_new ("(b)",
                   arg_enable),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_enable_module:
 * @proxy: A #UDisksManagerProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_enable: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.EnableModule">EnableModule()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_call_enable_module_finish() to get the result of the operation.
 *
 * See udisks_manager_call_enable_module_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.9.0
 */
void
udisks_manager_call_enable_module (
    UDisksManager *proxy,
    const gchar *arg_name,
    gboolean arg_enable,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "EnableModule",
    g_variant_new ("(sb)",
                   arg_name,
                   arg_enable),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_call_enable_module_finish:
 * @proxy: A #UDisksManagerProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_call_enable_module().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_call_enable_module().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.9.0
 */
gboolean
udisks_manager_call_enable_module_finish (
    UDisksManager *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_enable_module_sync:
 * @proxy: A #UDisksManagerProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_enable: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.EnableModule">EnableModule()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_call_enable_module() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.9.0
 */
gboolean
udisks_manager_call_enable_module_sync (
    UDisksManager *proxy,
    const gchar *arg_name,
    gboolean arg_enable,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "EnableModule",
    g_variant_new ("(sb)",
                   arg_name,
                   arg_enable),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_get_block_devices:
 * @proxy: A #UDisksManagerProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.GetBlockDevices">GetBlockDevices()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_call_get_block_devices_finish() to get the result of the operation.
 *
 * See udisks_manager_call_get_block_devices_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.7.2
 */
void
udisks_manager_call_get_block_devices (
    UDisksManager *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "GetBlockDevices",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_call_get_block_devices_finish:
 * @proxy: A #UDisksManagerProxy.
 * @out_block_objects: (out) (optional) (array zero-terminated=1): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_call_get_block_devices().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_call_get_block_devices().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.2
 */
gboolean
udisks_manager_call_get_block_devices_finish (
    UDisksManager *proxy,
    gchar *** out_block_objects,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(^ao)",
                 out_block_objects);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_get_block_devices_sync:
 * @proxy: A #UDisksManagerProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @out_block_objects: (out) (optional) (array zero-terminated=1): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.GetBlockDevices">GetBlockDevices()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_call_get_block_devices() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.2
 */
gboolean
udisks_manager_call_get_block_devices_sync (
    UDisksManager *proxy,
    GVariant *arg_options,
    gchar *** out_block_objects,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "GetBlockDevices",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(^ao)",
                 out_block_objects);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_get_drives:
 * @proxy: A #UDisksManagerProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.GetDrives">GetDrives()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_call_get_drives_finish() to get the result of the operation.
 *
 * See udisks_manager_call_get_drives_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.11
 */
void
udisks_manager_call_get_drives (
    UDisksManager *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "GetDrives",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_call_get_drives_finish:
 * @proxy: A #UDisksManagerProxy.
 * @out_drive_objects: (out) (optional) (array zero-terminated=1): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_call_get_drives().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_call_get_drives().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11
 */
gboolean
udisks_manager_call_get_drives_finish (
    UDisksManager *proxy,
    gchar *** out_drive_objects,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(^ao)",
                 out_drive_objects);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_get_drives_sync:
 * @proxy: A #UDisksManagerProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @out_drive_objects: (out) (optional) (array zero-terminated=1): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.GetDrives">GetDrives()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_call_get_drives() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11
 */
gboolean
udisks_manager_call_get_drives_sync (
    UDisksManager *proxy,
    GVariant *arg_options,
    gchar *** out_drive_objects,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "GetDrives",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(^ao)",
                 out_drive_objects);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_resolve_device:
 * @proxy: A #UDisksManagerProxy.
 * @arg_devspec: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.ResolveDevice">ResolveDevice()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_call_resolve_device_finish() to get the result of the operation.
 *
 * See udisks_manager_call_resolve_device_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.7.3
 */
void
udisks_manager_call_resolve_device (
    UDisksManager *proxy,
    GVariant *arg_devspec,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "ResolveDevice",
    g_variant_new ("(@a{sv}@a{sv})",
                   arg_devspec,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_call_resolve_device_finish:
 * @proxy: A #UDisksManagerProxy.
 * @out_devices: (out) (optional) (array zero-terminated=1): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_call_resolve_device().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_call_resolve_device().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.3
 */
gboolean
udisks_manager_call_resolve_device_finish (
    UDisksManager *proxy,
    gchar *** out_devices,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(^ao)",
                 out_devices);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_call_resolve_device_sync:
 * @proxy: A #UDisksManagerProxy.
 * @arg_devspec: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_devices: (out) (optional) (array zero-terminated=1): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.ResolveDevice">ResolveDevice()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_call_resolve_device() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.3
 */
gboolean
udisks_manager_call_resolve_device_sync (
    UDisksManager *proxy,
    GVariant *arg_devspec,
    GVariant *arg_options,
    gchar *** out_devices,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "ResolveDevice",
    g_variant_new ("(@a{sv}@a{sv})",
                   arg_devspec,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(^ao)",
                 out_devices);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_complete_can_format:
 * @object: A #UDisksManager.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @available: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanFormat">CanFormat()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.7.2
 */
void
udisks_manager_complete_can_format (
    UDisksManager *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GVariant *available)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(@(bs))",
                   available));
}

/**
 * udisks_manager_complete_can_resize:
 * @object: A #UDisksManager.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @available: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanResize">CanResize()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.7.2
 */
void
udisks_manager_complete_can_resize (
    UDisksManager *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GVariant *available)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(@(bts))",
                   available));
}

/**
 * udisks_manager_complete_can_check:
 * @object: A #UDisksManager.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @available: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanCheck">CanCheck()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.7.2
 */
void
udisks_manager_complete_can_check (
    UDisksManager *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GVariant *available)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(@(bs))",
                   available));
}

/**
 * udisks_manager_complete_can_repair:
 * @object: A #UDisksManager.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @available: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.CanRepair">CanRepair()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.7.2
 */
void
udisks_manager_complete_can_repair (
    UDisksManager *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GVariant *available)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(@(bs))",
                   available));
}

/**
 * udisks_manager_complete_loop_setup:
 * @object: A #UDisksManager.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @resulting_device: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.LoopSetup">LoopSetup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_manager_complete_loop_setup (
    UDisksManager *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    const gchar *resulting_device)
{
  g_dbus_method_invocation_return_value_with_unix_fd_list (invocation,
    g_variant_new ("(o)",
                   resulting_device),
    fd_list);
}

/**
 * udisks_manager_complete_mdraid_create:
 * @object: A #UDisksManager.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @resulting_array: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.MDRaidCreate">MDRaidCreate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_manager_complete_mdraid_create (
    UDisksManager *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *resulting_array)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   resulting_array));
}

/**
 * udisks_manager_complete_enable_modules:
 * @object: A #UDisksManager.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.EnableModules">EnableModules()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Deprecated: The D-Bus method has been deprecated.
 */
void
udisks_manager_complete_enable_modules (
    UDisksManager *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_manager_complete_enable_module:
 * @object: A #UDisksManager.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.EnableModule">EnableModule()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.9.0
 */
void
udisks_manager_complete_enable_module (
    UDisksManager *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_manager_complete_get_block_devices:
 * @object: A #UDisksManager.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @block_objects: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.GetBlockDevices">GetBlockDevices()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.7.2
 */
void
udisks_manager_complete_get_block_devices (
    UDisksManager *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *const *block_objects)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(^ao)",
                   block_objects));
}

/**
 * udisks_manager_complete_get_drives:
 * @object: A #UDisksManager.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @drive_objects: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.GetDrives">GetDrives()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.11
 */
void
udisks_manager_complete_get_drives (
    UDisksManager *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *const *drive_objects)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(^ao)",
                   drive_objects));
}

/**
 * udisks_manager_complete_resolve_device:
 * @object: A #UDisksManager.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @devices: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager.ResolveDevice">ResolveDevice()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.7.3
 */
void
udisks_manager_complete_resolve_device (
    UDisksManager *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *const *devices)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(^ao)",
                   devices));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksManagerProxy:
 *
 * The #UDisksManagerProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksManagerProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksManagerProxy.
 */

struct _UDisksManagerProxyPrivate
{
  GData *qdata;
};

static void udisks_manager_proxy_iface_init (UDisksManagerIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksManagerProxy, udisks_manager_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksManagerProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER, udisks_manager_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksManagerProxy, udisks_manager_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER, udisks_manager_proxy_iface_init))

#endif
static void
udisks_manager_proxy_finalize (GObject *object)
{
  UDisksManagerProxy *proxy = UDISKS_MANAGER_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_manager_proxy_parent_class)->finalize (object);
}

static void
udisks_manager_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_manager_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_manager_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.Manager: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_manager_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_manager_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.Manager", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_manager_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_manager_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_manager_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_MANAGER);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_MANAGER);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_manager_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksManagerProxy *proxy = UDISKS_MANAGER_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_manager_proxy_get_version (UDisksManager *object)
{
  UDisksManagerProxy *proxy = UDISKS_MANAGER_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Version");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *const *
udisks_manager_proxy_get_supported_filesystems (UDisksManager *object)
{
  UDisksManagerProxy *proxy = UDISKS_MANAGER_PROXY (object);
  GVariant *variant;
  const gchar *const *value = NULL;
  value = g_datalist_get_data (&proxy->priv->qdata, "SupportedFilesystems");
  if (value != NULL)
    return value;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SupportedFilesystems");
  if (variant != NULL)
    {
      value = g_variant_get_strv (variant, NULL);
      g_datalist_set_data_full (&proxy->priv->qdata, "SupportedFilesystems", (gpointer) value, g_free);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *const *
udisks_manager_proxy_get_supported_encryption_types (UDisksManager *object)
{
  UDisksManagerProxy *proxy = UDISKS_MANAGER_PROXY (object);
  GVariant *variant;
  const gchar *const *value = NULL;
  value = g_datalist_get_data (&proxy->priv->qdata, "SupportedEncryptionTypes");
  if (value != NULL)
    return value;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SupportedEncryptionTypes");
  if (variant != NULL)
    {
      value = g_variant_get_strv (variant, NULL);
      g_datalist_set_data_full (&proxy->priv->qdata, "SupportedEncryptionTypes", (gpointer) value, g_free);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_manager_proxy_get_default_encryption_type (UDisksManager *object)
{
  UDisksManagerProxy *proxy = UDISKS_MANAGER_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "DefaultEncryptionType");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_manager_proxy_init (UDisksManagerProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_manager_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_MANAGER_PROXY, UDisksManagerProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_manager_interface_info ());
}

static void
udisks_manager_proxy_class_init (UDisksManagerProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_manager_proxy_finalize;
  gobject_class->get_property = udisks_manager_proxy_get_property;
  gobject_class->set_property = udisks_manager_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_manager_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_manager_proxy_g_properties_changed;

  udisks_manager_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksManagerProxyPrivate));
#endif
}

static void
udisks_manager_proxy_iface_init (UDisksManagerIface *iface)
{
  iface->get_version = udisks_manager_proxy_get_version;
  iface->get_supported_filesystems = udisks_manager_proxy_get_supported_filesystems;
  iface->get_supported_encryption_types = udisks_manager_proxy_get_supported_encryption_types;
  iface->get_default_encryption_type = udisks_manager_proxy_get_default_encryption_type;
}

/**
 * udisks_manager_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager.top_of_page">org.freedesktop.UDisks2.Manager</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_manager_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_manager_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_MANAGER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager", NULL);
}

/**
 * udisks_manager_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_manager_proxy_new().
 *
 * Returns: (transfer full) (type UDisksManagerProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksManager *
udisks_manager_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_MANAGER (ret);
  else
    return NULL;
}

/**
 * udisks_manager_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager.top_of_page">org.freedesktop.UDisks2.Manager</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksManagerProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksManager *
udisks_manager_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_MANAGER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager", NULL);
  if (ret != NULL)
    return UDISKS_MANAGER (ret);
  else
    return NULL;
}


/**
 * udisks_manager_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_manager_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_manager_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_manager_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_MANAGER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager", NULL);
}

/**
 * udisks_manager_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_manager_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksManagerProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksManager *
udisks_manager_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_MANAGER (ret);
  else
    return NULL;
}

/**
 * udisks_manager_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_manager_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksManagerProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksManager *
udisks_manager_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_MANAGER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager", NULL);
  if (ret != NULL)
    return UDISKS_MANAGER (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksManagerSkeleton:
 *
 * The #UDisksManagerSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksManagerSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksManagerSkeleton.
 */

struct _UDisksManagerSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_manager_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_MANAGER);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_MANAGER);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_manager_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_manager_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_manager_skeleton_vtable =
{
  _udisks_manager_skeleton_handle_method_call,
  _udisks_manager_skeleton_handle_get_property,
  _udisks_manager_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_manager_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_manager_interface_info ();
}

static GDBusInterfaceVTable *
udisks_manager_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_manager_skeleton_vtable;
}

static GVariant *
udisks_manager_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_manager_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_manager_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_manager_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_manager_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Manager", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_manager_emit_changed (gpointer user_data);

static void
udisks_manager_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_manager_emit_changed (skeleton);
}

static void udisks_manager_skeleton_iface_init (UDisksManagerIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksManagerSkeleton, udisks_manager_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksManagerSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER, udisks_manager_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksManagerSkeleton, udisks_manager_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER, udisks_manager_skeleton_iface_init))

#endif
static void
udisks_manager_skeleton_finalize (GObject *object)
{
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (object);
  guint n;
  for (n = 0; n < 4; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_manager_skeleton_parent_class)->finalize (object);
}

static void
udisks_manager_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_manager_emit_changed (gpointer user_data)
{
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.Manager",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_manager_schedule_emit_changed (UDisksManagerSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_manager_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_manager_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_manager_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_manager_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_manager_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_manager_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_manager_skeleton_init (UDisksManagerSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_manager_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_MANAGER_SKELETON, UDisksManagerSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 4);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRV);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_STRV);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_STRING);
}

static const gchar *
udisks_manager_skeleton_get_version (UDisksManager *object)
{
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *const *
udisks_manager_skeleton_get_supported_filesystems (UDisksManager *object)
{
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (object);
  const gchar *const *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boxed (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *const *
udisks_manager_skeleton_get_supported_encryption_types (UDisksManager *object)
{
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (object);
  const gchar *const *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boxed (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_manager_skeleton_get_default_encryption_type (UDisksManager *object)
{
  UDisksManagerSkeleton *skeleton = UDISKS_MANAGER_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_manager_skeleton_class_init (UDisksManagerSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_manager_skeleton_finalize;
  gobject_class->get_property = udisks_manager_skeleton_get_property;
  gobject_class->set_property = udisks_manager_skeleton_set_property;
  gobject_class->notify       = udisks_manager_skeleton_notify;


  udisks_manager_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_manager_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_manager_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_manager_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_manager_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksManagerSkeletonPrivate));
#endif
}

static void
udisks_manager_skeleton_iface_init (UDisksManagerIface *iface)
{
  iface->get_version = udisks_manager_skeleton_get_version;
  iface->get_supported_filesystems = udisks_manager_skeleton_get_supported_filesystems;
  iface->get_supported_encryption_types = udisks_manager_skeleton_get_supported_encryption_types;
  iface->get_default_encryption_type = udisks_manager_skeleton_get_default_encryption_type;
}

/**
 * udisks_manager_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager.top_of_page">org.freedesktop.UDisks2.Manager</link>.
 *
 * Returns: (transfer full) (type UDisksManagerSkeleton): The skeleton object.
 */
UDisksManager *
udisks_manager_skeleton_new (void)
{
  return UDISKS_MANAGER (g_object_new (UDISKS_TYPE_MANAGER_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Manager.NVMe
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksManagerNVMe
 * @title: UDisksManagerNVMe
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Manager.NVMe D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-NVMe.top_of_page">org.freedesktop.UDisks2.Manager.NVMe</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Manager.NVMe ---- */

static const _ExtendedGDBusArgInfo _udisks_manager_nvme_method_info_set_host_nqn_IN_ARG_hostnqn =
{
  {
    -1,
    (gchar *) "hostnqn",
    (gchar *) "ay",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_nvme_method_info_set_host_nqn_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_nvme_method_info_set_host_nqn_IN_ARG_pointers[] =
{
  &_udisks_manager_nvme_method_info_set_host_nqn_IN_ARG_hostnqn.parent_struct,
  &_udisks_manager_nvme_method_info_set_host_nqn_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_nvme_method_info_set_host_nqn =
{
  {
    -1,
    (gchar *) "SetHostNQN",
    (GDBusArgInfo **) &_udisks_manager_nvme_method_info_set_host_nqn_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-host-nqn",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_nvme_method_info_set_host_id_IN_ARG_hostid =
{
  {
    -1,
    (gchar *) "hostid",
    (gchar *) "ay",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_nvme_method_info_set_host_id_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_nvme_method_info_set_host_id_IN_ARG_pointers[] =
{
  &_udisks_manager_nvme_method_info_set_host_id_IN_ARG_hostid.parent_struct,
  &_udisks_manager_nvme_method_info_set_host_id_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_nvme_method_info_set_host_id =
{
  {
    -1,
    (gchar *) "SetHostID",
    (GDBusArgInfo **) &_udisks_manager_nvme_method_info_set_host_id_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-host-id",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_nvme_method_info_connect_IN_ARG_subsysnqn =
{
  {
    -1,
    (gchar *) "subsysnqn",
    (gchar *) "ay",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_nvme_method_info_connect_IN_ARG_transport =
{
  {
    -1,
    (gchar *) "transport",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_nvme_method_info_connect_IN_ARG_transport_addr =
{
  {
    -1,
    (gchar *) "transport_addr",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_nvme_method_info_connect_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_nvme_method_info_connect_IN_ARG_pointers[] =
{
  &_udisks_manager_nvme_method_info_connect_IN_ARG_subsysnqn.parent_struct,
  &_udisks_manager_nvme_method_info_connect_IN_ARG_transport.parent_struct,
  &_udisks_manager_nvme_method_info_connect_IN_ARG_transport_addr.parent_struct,
  &_udisks_manager_nvme_method_info_connect_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_manager_nvme_method_info_connect_OUT_ARG_nvme_ctrl =
{
  {
    -1,
    (gchar *) "nvme_ctrl",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_nvme_method_info_connect_OUT_ARG_pointers[] =
{
  &_udisks_manager_nvme_method_info_connect_OUT_ARG_nvme_ctrl.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_nvme_method_info_connect =
{
  {
    -1,
    (gchar *) "Connect",
    (GDBusArgInfo **) &_udisks_manager_nvme_method_info_connect_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_manager_nvme_method_info_connect_OUT_ARG_pointers,
    NULL
  },
  "handle-connect",
  FALSE
};

static const GDBusMethodInfo * const _udisks_manager_nvme_method_info_pointers[] =
{
  &_udisks_manager_nvme_method_info_set_host_nqn.parent_struct,
  &_udisks_manager_nvme_method_info_set_host_id.parent_struct,
  &_udisks_manager_nvme_method_info_connect.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_manager_nvme_property_info_host_nqn =
{
  {
    -1,
    (gchar *) "HostNQN",
    (gchar *) "ay",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "host-nqn",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_manager_nvme_property_info_host_id =
{
  {
    -1,
    (gchar *) "HostID",
    (gchar *) "ay",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "host-id",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_manager_nvme_property_info_pointers[] =
{
  &_udisks_manager_nvme_property_info_host_nqn.parent_struct,
  &_udisks_manager_nvme_property_info_host_id.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_manager_nvme_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Manager.NVMe",
    (GDBusMethodInfo **) &_udisks_manager_nvme_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_manager_nvme_property_info_pointers,
    NULL
  },
  "manager-nvme",
};


/**
 * udisks_manager_nvme_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-NVMe.top_of_page">org.freedesktop.UDisks2.Manager.NVMe</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_manager_nvme_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_manager_nvme_interface_info.parent_struct;
}

/**
 * udisks_manager_nvme_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksManagerNVMe interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_manager_nvme_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "host-nqn");
  g_object_class_override_property (klass, property_id_begin++, "host-id");
  return property_id_begin - 1;
}


inline static void
udisks_manager_nvme_method_marshal_set_host_nqn (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_manager_nvme_method_marshal_set_host_id (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_manager_nvme_method_marshal_connect (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_STRING_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksManagerNVMe:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-NVMe.top_of_page">org.freedesktop.UDisks2.Manager.NVMe</link>.
 */

/**
 * UDisksManagerNVMeIface:
 * @parent_iface: The parent interface.
 * @get_host_id: Getter for the #UDisksManagerNVMe:host-id property.
 * @get_host_nqn: Getter for the #UDisksManagerNVMe:host-nqn property.
 * @handle_connect: Handler for the #UDisksManagerNVMe::handle-connect signal.
 * @handle_set_host_id: Handler for the #UDisksManagerNVMe::handle-set-host-id signal.
 * @handle_set_host_nqn: Handler for the #UDisksManagerNVMe::handle-set-host-nqn signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-NVMe.top_of_page">org.freedesktop.UDisks2.Manager.NVMe</link>.
 */

typedef UDisksManagerNVMeIface UDisksManagerNVMeInterface;
G_DEFINE_INTERFACE (UDisksManagerNVMe, udisks_manager_nvme, G_TYPE_OBJECT)

static void
udisks_manager_nvme_default_init (UDisksManagerNVMeIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksManagerNVMe::handle-set-host-nqn:
   * @object: A #UDisksManagerNVMe.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_hostnqn: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-NVMe.SetHostNQN">SetHostNQN()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_nvme_complete_set_host_nqn() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.10.0
   */
  g_signal_new ("handle-set-host-nqn",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerNVMeIface, handle_set_host_nqn),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_nvme_method_marshal_set_host_nqn,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksManagerNVMe::handle-set-host-id:
   * @object: A #UDisksManagerNVMe.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_hostid: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-NVMe.SetHostID">SetHostID()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_nvme_complete_set_host_id() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.10.0
   */
  g_signal_new ("handle-set-host-id",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerNVMeIface, handle_set_host_id),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_nvme_method_marshal_set_host_id,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksManagerNVMe::handle-connect:
   * @object: A #UDisksManagerNVMe.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_subsysnqn: Argument passed by remote caller.
   * @arg_transport: Argument passed by remote caller.
   * @arg_transport_addr: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-NVMe.Connect">Connect()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_nvme_complete_connect() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.10.0
   */
  g_signal_new ("handle-connect",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerNVMeIface, handle_connect),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_nvme_method_marshal_connect,
    G_TYPE_BOOLEAN,
    5,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksManagerNVMe:host-nqn:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager-NVMe.HostNQN">"HostNQN"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("host-nqn", "HostNQN", "HostNQN", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksManagerNVMe:host-id:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager-NVMe.HostID">"HostID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("host-id", "HostID", "HostID", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_manager_nvme_get_host_nqn: (skip)
 * @object: A #UDisksManagerNVMe.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager-NVMe.HostNQN">"HostNQN"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_manager_nvme_dup_host_nqn() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_manager_nvme_get_host_nqn (UDisksManagerNVMe *object)
{
  g_return_val_if_fail (UDISKS_IS_MANAGER_NVME (object), NULL);

  return UDISKS_MANAGER_NVME_GET_IFACE (object)->get_host_nqn (object);
}

/**
 * udisks_manager_nvme_dup_host_nqn: (skip)
 * @object: A #UDisksManagerNVMe.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager-NVMe.HostNQN">"HostNQN"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_manager_nvme_dup_host_nqn (UDisksManagerNVMe *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "host-nqn", &value, NULL);
  return value;
}

/**
 * udisks_manager_nvme_set_host_nqn: (skip)
 * @object: A #UDisksManagerNVMe.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager-NVMe.HostNQN">"HostNQN"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_manager_nvme_set_host_nqn (UDisksManagerNVMe *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "host-nqn", value, NULL);
}

/**
 * udisks_manager_nvme_get_host_id: (skip)
 * @object: A #UDisksManagerNVMe.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager-NVMe.HostID">"HostID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_manager_nvme_dup_host_id() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_manager_nvme_get_host_id (UDisksManagerNVMe *object)
{
  g_return_val_if_fail (UDISKS_IS_MANAGER_NVME (object), NULL);

  return UDISKS_MANAGER_NVME_GET_IFACE (object)->get_host_id (object);
}

/**
 * udisks_manager_nvme_dup_host_id: (skip)
 * @object: A #UDisksManagerNVMe.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager-NVMe.HostID">"HostID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_manager_nvme_dup_host_id (UDisksManagerNVMe *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "host-id", &value, NULL);
  return value;
}

/**
 * udisks_manager_nvme_set_host_id: (skip)
 * @object: A #UDisksManagerNVMe.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Manager-NVMe.HostID">"HostID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_manager_nvme_set_host_id (UDisksManagerNVMe *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "host-id", value, NULL);
}

/**
 * udisks_manager_nvme_call_set_host_nqn:
 * @proxy: A #UDisksManagerNVMeProxy.
 * @arg_hostnqn: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-NVMe.SetHostNQN">SetHostNQN()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_nvme_call_set_host_nqn_finish() to get the result of the operation.
 *
 * See udisks_manager_nvme_call_set_host_nqn_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.10.0
 */
void
udisks_manager_nvme_call_set_host_nqn (
    UDisksManagerNVMe *proxy,
    const gchar *arg_hostnqn,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetHostNQN",
    g_variant_new ("(^ay@a{sv})",
                   arg_hostnqn,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_nvme_call_set_host_nqn_finish:
 * @proxy: A #UDisksManagerNVMeProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_nvme_call_set_host_nqn().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_nvme_call_set_host_nqn().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_manager_nvme_call_set_host_nqn_finish (
    UDisksManagerNVMe *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_nvme_call_set_host_nqn_sync:
 * @proxy: A #UDisksManagerNVMeProxy.
 * @arg_hostnqn: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-NVMe.SetHostNQN">SetHostNQN()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_nvme_call_set_host_nqn() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_manager_nvme_call_set_host_nqn_sync (
    UDisksManagerNVMe *proxy,
    const gchar *arg_hostnqn,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetHostNQN",
    g_variant_new ("(^ay@a{sv})",
                   arg_hostnqn,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_nvme_call_set_host_id:
 * @proxy: A #UDisksManagerNVMeProxy.
 * @arg_hostid: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-NVMe.SetHostID">SetHostID()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_nvme_call_set_host_id_finish() to get the result of the operation.
 *
 * See udisks_manager_nvme_call_set_host_id_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.10.0
 */
void
udisks_manager_nvme_call_set_host_id (
    UDisksManagerNVMe *proxy,
    const gchar *arg_hostid,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetHostID",
    g_variant_new ("(^ay@a{sv})",
                   arg_hostid,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_nvme_call_set_host_id_finish:
 * @proxy: A #UDisksManagerNVMeProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_nvme_call_set_host_id().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_nvme_call_set_host_id().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_manager_nvme_call_set_host_id_finish (
    UDisksManagerNVMe *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_nvme_call_set_host_id_sync:
 * @proxy: A #UDisksManagerNVMeProxy.
 * @arg_hostid: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-NVMe.SetHostID">SetHostID()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_nvme_call_set_host_id() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_manager_nvme_call_set_host_id_sync (
    UDisksManagerNVMe *proxy,
    const gchar *arg_hostid,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetHostID",
    g_variant_new ("(^ay@a{sv})",
                   arg_hostid,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_nvme_call_connect:
 * @proxy: A #UDisksManagerNVMeProxy.
 * @arg_subsysnqn: Argument to pass with the method invocation.
 * @arg_transport: Argument to pass with the method invocation.
 * @arg_transport_addr: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-NVMe.Connect">Connect()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_nvme_call_connect_finish() to get the result of the operation.
 *
 * See udisks_manager_nvme_call_connect_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.10.0
 */
void
udisks_manager_nvme_call_connect (
    UDisksManagerNVMe *proxy,
    const gchar *arg_subsysnqn,
    const gchar *arg_transport,
    const gchar *arg_transport_addr,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Connect",
    g_variant_new ("(^ayss@a{sv})",
                   arg_subsysnqn,
                   arg_transport,
                   arg_transport_addr,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_nvme_call_connect_finish:
 * @proxy: A #UDisksManagerNVMeProxy.
 * @out_nvme_ctrl: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_nvme_call_connect().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_nvme_call_connect().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_manager_nvme_call_connect_finish (
    UDisksManagerNVMe *proxy,
    gchar ** out_nvme_ctrl,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_nvme_ctrl);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_nvme_call_connect_sync:
 * @proxy: A #UDisksManagerNVMeProxy.
 * @arg_subsysnqn: Argument to pass with the method invocation.
 * @arg_transport: Argument to pass with the method invocation.
 * @arg_transport_addr: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_nvme_ctrl: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-NVMe.Connect">Connect()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_nvme_call_connect() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_manager_nvme_call_connect_sync (
    UDisksManagerNVMe *proxy,
    const gchar *arg_subsysnqn,
    const gchar *arg_transport,
    const gchar *arg_transport_addr,
    GVariant *arg_options,
    gchar ** out_nvme_ctrl,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Connect",
    g_variant_new ("(^ayss@a{sv})",
                   arg_subsysnqn,
                   arg_transport,
                   arg_transport_addr,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_nvme_ctrl);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_nvme_complete_set_host_nqn:
 * @object: A #UDisksManagerNVMe.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-NVMe.SetHostNQN">SetHostNQN()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.10.0
 */
void
udisks_manager_nvme_complete_set_host_nqn (
    UDisksManagerNVMe *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_manager_nvme_complete_set_host_id:
 * @object: A #UDisksManagerNVMe.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-NVMe.SetHostID">SetHostID()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.10.0
 */
void
udisks_manager_nvme_complete_set_host_id (
    UDisksManagerNVMe *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_manager_nvme_complete_connect:
 * @object: A #UDisksManagerNVMe.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @nvme_ctrl: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-NVMe.Connect">Connect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.10.0
 */
void
udisks_manager_nvme_complete_connect (
    UDisksManagerNVMe *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *nvme_ctrl)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   nvme_ctrl));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksManagerNVMeProxy:
 *
 * The #UDisksManagerNVMeProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksManagerNVMeProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksManagerNVMeProxy.
 */

struct _UDisksManagerNVMeProxyPrivate
{
  GData *qdata;
};

static void udisks_manager_nvme_proxy_iface_init (UDisksManagerNVMeIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksManagerNVMeProxy, udisks_manager_nvme_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksManagerNVMeProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER_NVME, udisks_manager_nvme_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksManagerNVMeProxy, udisks_manager_nvme_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER_NVME, udisks_manager_nvme_proxy_iface_init))

#endif
static void
udisks_manager_nvme_proxy_finalize (GObject *object)
{
  UDisksManagerNVMeProxy *proxy = UDISKS_MANAGER_NVME_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_manager_nvme_proxy_parent_class)->finalize (object);
}

static void
udisks_manager_nvme_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 2);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_manager_nvme_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_manager_nvme_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.Manager.NVMe: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_manager_nvme_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 2);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_manager_nvme_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.Manager.NVMe", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_manager_nvme_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_manager_nvme_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_manager_nvme_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_MANAGER_NVME);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_MANAGER_NVME);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_manager_nvme_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksManagerNVMeProxy *proxy = UDISKS_MANAGER_NVME_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_nvme_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_nvme_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_manager_nvme_proxy_get_host_nqn (UDisksManagerNVMe *object)
{
  UDisksManagerNVMeProxy *proxy = UDISKS_MANAGER_NVME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "HostNQN");
  if (variant != NULL)
    {
      value = g_variant_get_bytestring (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_manager_nvme_proxy_get_host_id (UDisksManagerNVMe *object)
{
  UDisksManagerNVMeProxy *proxy = UDISKS_MANAGER_NVME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "HostID");
  if (variant != NULL)
    {
      value = g_variant_get_bytestring (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_manager_nvme_proxy_init (UDisksManagerNVMeProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_manager_nvme_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_MANAGER_NVME_PROXY, UDisksManagerNVMeProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_manager_nvme_interface_info ());
}

static void
udisks_manager_nvme_proxy_class_init (UDisksManagerNVMeProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_manager_nvme_proxy_finalize;
  gobject_class->get_property = udisks_manager_nvme_proxy_get_property;
  gobject_class->set_property = udisks_manager_nvme_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_manager_nvme_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_manager_nvme_proxy_g_properties_changed;

  udisks_manager_nvme_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksManagerNVMeProxyPrivate));
#endif
}

static void
udisks_manager_nvme_proxy_iface_init (UDisksManagerNVMeIface *iface)
{
  iface->get_host_nqn = udisks_manager_nvme_proxy_get_host_nqn;
  iface->get_host_id = udisks_manager_nvme_proxy_get_host_id;
}

/**
 * udisks_manager_nvme_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-NVMe.top_of_page">org.freedesktop.UDisks2.Manager.NVMe</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_nvme_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_manager_nvme_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_manager_nvme_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_MANAGER_NVME_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager.NVMe", NULL);
}

/**
 * udisks_manager_nvme_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_nvme_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_manager_nvme_proxy_new().
 *
 * Returns: (transfer full) (type UDisksManagerNVMeProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksManagerNVMe *
udisks_manager_nvme_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_MANAGER_NVME (ret);
  else
    return NULL;
}

/**
 * udisks_manager_nvme_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-NVMe.top_of_page">org.freedesktop.UDisks2.Manager.NVMe</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_nvme_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksManagerNVMeProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksManagerNVMe *
udisks_manager_nvme_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_MANAGER_NVME_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager.NVMe", NULL);
  if (ret != NULL)
    return UDISKS_MANAGER_NVME (ret);
  else
    return NULL;
}


/**
 * udisks_manager_nvme_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_manager_nvme_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_nvme_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_manager_nvme_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_manager_nvme_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_MANAGER_NVME_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager.NVMe", NULL);
}

/**
 * udisks_manager_nvme_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_nvme_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_manager_nvme_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksManagerNVMeProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksManagerNVMe *
udisks_manager_nvme_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_MANAGER_NVME (ret);
  else
    return NULL;
}

/**
 * udisks_manager_nvme_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_manager_nvme_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_nvme_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksManagerNVMeProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksManagerNVMe *
udisks_manager_nvme_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_MANAGER_NVME_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager.NVMe", NULL);
  if (ret != NULL)
    return UDISKS_MANAGER_NVME (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksManagerNVMeSkeleton:
 *
 * The #UDisksManagerNVMeSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksManagerNVMeSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksManagerNVMeSkeleton.
 */

struct _UDisksManagerNVMeSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_manager_nvme_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksManagerNVMeSkeleton *skeleton = UDISKS_MANAGER_NVME_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_MANAGER_NVME);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_MANAGER_NVME);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_manager_nvme_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksManagerNVMeSkeleton *skeleton = UDISKS_MANAGER_NVME_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_nvme_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_manager_nvme_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksManagerNVMeSkeleton *skeleton = UDISKS_MANAGER_NVME_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_nvme_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_manager_nvme_skeleton_vtable =
{
  _udisks_manager_nvme_skeleton_handle_method_call,
  _udisks_manager_nvme_skeleton_handle_get_property,
  _udisks_manager_nvme_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_manager_nvme_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_manager_nvme_interface_info ();
}

static GDBusInterfaceVTable *
udisks_manager_nvme_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_manager_nvme_skeleton_vtable;
}

static GVariant *
udisks_manager_nvme_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksManagerNVMeSkeleton *skeleton = UDISKS_MANAGER_NVME_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_manager_nvme_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_manager_nvme_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_manager_nvme_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_manager_nvme_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Manager.NVMe", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_manager_nvme_emit_changed (gpointer user_data);

static void
udisks_manager_nvme_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksManagerNVMeSkeleton *skeleton = UDISKS_MANAGER_NVME_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_manager_nvme_emit_changed (skeleton);
}

static void udisks_manager_nvme_skeleton_iface_init (UDisksManagerNVMeIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksManagerNVMeSkeleton, udisks_manager_nvme_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksManagerNVMeSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER_NVME, udisks_manager_nvme_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksManagerNVMeSkeleton, udisks_manager_nvme_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER_NVME, udisks_manager_nvme_skeleton_iface_init))

#endif
static void
udisks_manager_nvme_skeleton_finalize (GObject *object)
{
  UDisksManagerNVMeSkeleton *skeleton = UDISKS_MANAGER_NVME_SKELETON (object);
  guint n;
  for (n = 0; n < 2; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_manager_nvme_skeleton_parent_class)->finalize (object);
}

static void
udisks_manager_nvme_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksManagerNVMeSkeleton *skeleton = UDISKS_MANAGER_NVME_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 2);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_manager_nvme_emit_changed (gpointer user_data)
{
  UDisksManagerNVMeSkeleton *skeleton = UDISKS_MANAGER_NVME_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.Manager.NVMe",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_manager_nvme_schedule_emit_changed (UDisksManagerNVMeSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_manager_nvme_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksManagerNVMeSkeleton *skeleton = UDISKS_MANAGER_NVME_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_manager_nvme_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_manager_nvme_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_manager_nvme_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksManagerNVMeSkeleton *skeleton = UDISKS_MANAGER_NVME_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 2);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_manager_nvme_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_manager_nvme_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_manager_nvme_skeleton_init (UDisksManagerNVMeSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_manager_nvme_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_MANAGER_NVME_SKELETON, UDisksManagerNVMeSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 2);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING);
}

static const gchar *
udisks_manager_nvme_skeleton_get_host_nqn (UDisksManagerNVMe *object)
{
  UDisksManagerNVMeSkeleton *skeleton = UDISKS_MANAGER_NVME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_manager_nvme_skeleton_get_host_id (UDisksManagerNVMe *object)
{
  UDisksManagerNVMeSkeleton *skeleton = UDISKS_MANAGER_NVME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_manager_nvme_skeleton_class_init (UDisksManagerNVMeSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_manager_nvme_skeleton_finalize;
  gobject_class->get_property = udisks_manager_nvme_skeleton_get_property;
  gobject_class->set_property = udisks_manager_nvme_skeleton_set_property;
  gobject_class->notify       = udisks_manager_nvme_skeleton_notify;


  udisks_manager_nvme_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_manager_nvme_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_manager_nvme_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_manager_nvme_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_manager_nvme_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksManagerNVMeSkeletonPrivate));
#endif
}

static void
udisks_manager_nvme_skeleton_iface_init (UDisksManagerNVMeIface *iface)
{
  iface->get_host_nqn = udisks_manager_nvme_skeleton_get_host_nqn;
  iface->get_host_id = udisks_manager_nvme_skeleton_get_host_id;
}

/**
 * udisks_manager_nvme_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-NVMe.top_of_page">org.freedesktop.UDisks2.Manager.NVMe</link>.
 *
 * Returns: (transfer full) (type UDisksManagerNVMeSkeleton): The skeleton object.
 */
UDisksManagerNVMe *
udisks_manager_nvme_skeleton_new (void)
{
  return UDISKS_MANAGER_NVME (g_object_new (UDISKS_TYPE_MANAGER_NVME_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Drive
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksDrive
 * @title: UDisksDrive
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Drive D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive.top_of_page">org.freedesktop.UDisks2.Drive</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Drive ---- */

static const _ExtendedGDBusArgInfo _udisks_drive_method_info_eject_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_method_info_eject_IN_ARG_pointers[] =
{
  &_udisks_drive_method_info_eject_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_drive_method_info_eject =
{
  {
    -1,
    (gchar *) "Eject",
    (GDBusArgInfo **) &_udisks_drive_method_info_eject_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-eject",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_drive_method_info_set_configuration_IN_ARG_value =
{
  {
    -1,
    (gchar *) "value",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_drive_method_info_set_configuration_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_method_info_set_configuration_IN_ARG_pointers[] =
{
  &_udisks_drive_method_info_set_configuration_IN_ARG_value.parent_struct,
  &_udisks_drive_method_info_set_configuration_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_drive_method_info_set_configuration =
{
  {
    -1,
    (gchar *) "SetConfiguration",
    (GDBusArgInfo **) &_udisks_drive_method_info_set_configuration_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-configuration",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_drive_method_info_power_off_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_method_info_power_off_IN_ARG_pointers[] =
{
  &_udisks_drive_method_info_power_off_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_drive_method_info_power_off =
{
  {
    -1,
    (gchar *) "PowerOff",
    (GDBusArgInfo **) &_udisks_drive_method_info_power_off_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-power-off",
  FALSE
};

static const GDBusMethodInfo * const _udisks_drive_method_info_pointers[] =
{
  &_udisks_drive_method_info_eject.parent_struct,
  &_udisks_drive_method_info_set_configuration.parent_struct,
  &_udisks_drive_method_info_power_off.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_vendor =
{
  {
    -1,
    (gchar *) "Vendor",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "vendor",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_model =
{
  {
    -1,
    (gchar *) "Model",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "model",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_revision =
{
  {
    -1,
    (gchar *) "Revision",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "revision",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_serial =
{
  {
    -1,
    (gchar *) "Serial",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "serial",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_wwn =
{
  {
    -1,
    (gchar *) "WWN",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "wwn",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_id =
{
  {
    -1,
    (gchar *) "Id",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "id",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_configuration =
{
  {
    -1,
    (gchar *) "Configuration",
    (gchar *) "a{sv}",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "configuration",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_media =
{
  {
    -1,
    (gchar *) "Media",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "media",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_media_compatibility =
{
  {
    -1,
    (gchar *) "MediaCompatibility",
    (gchar *) "as",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "media-compatibility",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_media_removable =
{
  {
    -1,
    (gchar *) "MediaRemovable",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "media-removable",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_media_available =
{
  {
    -1,
    (gchar *) "MediaAvailable",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "media-available",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_media_change_detected =
{
  {
    -1,
    (gchar *) "MediaChangeDetected",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "media-change-detected",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_size =
{
  {
    -1,
    (gchar *) "Size",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "size",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_time_detected =
{
  {
    -1,
    (gchar *) "TimeDetected",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "time-detected",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_time_media_detected =
{
  {
    -1,
    (gchar *) "TimeMediaDetected",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "time-media-detected",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_optical =
{
  {
    -1,
    (gchar *) "Optical",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "optical",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_optical_blank =
{
  {
    -1,
    (gchar *) "OpticalBlank",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "optical-blank",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_optical_num_tracks =
{
  {
    -1,
    (gchar *) "OpticalNumTracks",
    (gchar *) "u",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "optical-num-tracks",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_optical_num_audio_tracks =
{
  {
    -1,
    (gchar *) "OpticalNumAudioTracks",
    (gchar *) "u",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "optical-num-audio-tracks",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_optical_num_data_tracks =
{
  {
    -1,
    (gchar *) "OpticalNumDataTracks",
    (gchar *) "u",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "optical-num-data-tracks",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_optical_num_sessions =
{
  {
    -1,
    (gchar *) "OpticalNumSessions",
    (gchar *) "u",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "optical-num-sessions",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_rotation_rate =
{
  {
    -1,
    (gchar *) "RotationRate",
    (gchar *) "i",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "rotation-rate",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_connection_bus =
{
  {
    -1,
    (gchar *) "ConnectionBus",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "connection-bus",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_seat =
{
  {
    -1,
    (gchar *) "Seat",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "seat",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_removable =
{
  {
    -1,
    (gchar *) "Removable",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "removable",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_ejectable =
{
  {
    -1,
    (gchar *) "Ejectable",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "ejectable",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_sort_key =
{
  {
    -1,
    (gchar *) "SortKey",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "sort-key",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_can_power_off =
{
  {
    -1,
    (gchar *) "CanPowerOff",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "can-power-off",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_property_info_sibling_id =
{
  {
    -1,
    (gchar *) "SiblingId",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "sibling-id",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_drive_property_info_pointers[] =
{
  &_udisks_drive_property_info_vendor.parent_struct,
  &_udisks_drive_property_info_model.parent_struct,
  &_udisks_drive_property_info_revision.parent_struct,
  &_udisks_drive_property_info_serial.parent_struct,
  &_udisks_drive_property_info_wwn.parent_struct,
  &_udisks_drive_property_info_id.parent_struct,
  &_udisks_drive_property_info_configuration.parent_struct,
  &_udisks_drive_property_info_media.parent_struct,
  &_udisks_drive_property_info_media_compatibility.parent_struct,
  &_udisks_drive_property_info_media_removable.parent_struct,
  &_udisks_drive_property_info_media_available.parent_struct,
  &_udisks_drive_property_info_media_change_detected.parent_struct,
  &_udisks_drive_property_info_size.parent_struct,
  &_udisks_drive_property_info_time_detected.parent_struct,
  &_udisks_drive_property_info_time_media_detected.parent_struct,
  &_udisks_drive_property_info_optical.parent_struct,
  &_udisks_drive_property_info_optical_blank.parent_struct,
  &_udisks_drive_property_info_optical_num_tracks.parent_struct,
  &_udisks_drive_property_info_optical_num_audio_tracks.parent_struct,
  &_udisks_drive_property_info_optical_num_data_tracks.parent_struct,
  &_udisks_drive_property_info_optical_num_sessions.parent_struct,
  &_udisks_drive_property_info_rotation_rate.parent_struct,
  &_udisks_drive_property_info_connection_bus.parent_struct,
  &_udisks_drive_property_info_seat.parent_struct,
  &_udisks_drive_property_info_removable.parent_struct,
  &_udisks_drive_property_info_ejectable.parent_struct,
  &_udisks_drive_property_info_sort_key.parent_struct,
  &_udisks_drive_property_info_can_power_off.parent_struct,
  &_udisks_drive_property_info_sibling_id.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_drive_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Drive",
    (GDBusMethodInfo **) &_udisks_drive_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_drive_property_info_pointers,
    NULL
  },
  "drive",
};


/**
 * udisks_drive_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive.top_of_page">org.freedesktop.UDisks2.Drive</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_drive_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_drive_interface_info.parent_struct;
}

/**
 * udisks_drive_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksDrive interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_drive_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "vendor");
  g_object_class_override_property (klass, property_id_begin++, "model");
  g_object_class_override_property (klass, property_id_begin++, "revision");
  g_object_class_override_property (klass, property_id_begin++, "serial");
  g_object_class_override_property (klass, property_id_begin++, "wwn");
  g_object_class_override_property (klass, property_id_begin++, "id");
  g_object_class_override_property (klass, property_id_begin++, "configuration");
  g_object_class_override_property (klass, property_id_begin++, "media");
  g_object_class_override_property (klass, property_id_begin++, "media-compatibility");
  g_object_class_override_property (klass, property_id_begin++, "media-removable");
  g_object_class_override_property (klass, property_id_begin++, "media-available");
  g_object_class_override_property (klass, property_id_begin++, "media-change-detected");
  g_object_class_override_property (klass, property_id_begin++, "size");
  g_object_class_override_property (klass, property_id_begin++, "time-detected");
  g_object_class_override_property (klass, property_id_begin++, "time-media-detected");
  g_object_class_override_property (klass, property_id_begin++, "optical");
  g_object_class_override_property (klass, property_id_begin++, "optical-blank");
  g_object_class_override_property (klass, property_id_begin++, "optical-num-tracks");
  g_object_class_override_property (klass, property_id_begin++, "optical-num-audio-tracks");
  g_object_class_override_property (klass, property_id_begin++, "optical-num-data-tracks");
  g_object_class_override_property (klass, property_id_begin++, "optical-num-sessions");
  g_object_class_override_property (klass, property_id_begin++, "rotation-rate");
  g_object_class_override_property (klass, property_id_begin++, "connection-bus");
  g_object_class_override_property (klass, property_id_begin++, "seat");
  g_object_class_override_property (klass, property_id_begin++, "removable");
  g_object_class_override_property (klass, property_id_begin++, "ejectable");
  g_object_class_override_property (klass, property_id_begin++, "sort-key");
  g_object_class_override_property (klass, property_id_begin++, "can-power-off");
  g_object_class_override_property (klass, property_id_begin++, "sibling-id");
  return property_id_begin - 1;
}


inline static void
udisks_drive_method_marshal_eject (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_drive_method_marshal_set_configuration (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_drive_method_marshal_power_off (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksDrive:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive.top_of_page">org.freedesktop.UDisks2.Drive</link>.
 */

/**
 * UDisksDriveIface:
 * @parent_iface: The parent interface.
 * @handle_eject: Handler for the #UDisksDrive::handle-eject signal.
 * @handle_set_configuration: Handler for the #UDisksDrive::handle-set-configuration signal.
 * @get_can_power_off: Getter for the #UDisksDrive:can-power-off property.
 * @get_configuration: Getter for the #UDisksDrive:configuration property.
 * @get_connection_bus: Getter for the #UDisksDrive:connection-bus property.
 * @get_ejectable: Getter for the #UDisksDrive:ejectable property.
 * @get_id: Getter for the #UDisksDrive:id property.
 * @get_media: Getter for the #UDisksDrive:media property.
 * @get_media_available: Getter for the #UDisksDrive:media-available property.
 * @get_media_change_detected: Getter for the #UDisksDrive:media-change-detected property.
 * @get_media_compatibility: Getter for the #UDisksDrive:media-compatibility property.
 * @get_media_removable: Getter for the #UDisksDrive:media-removable property.
 * @get_model: Getter for the #UDisksDrive:model property.
 * @get_optical: Getter for the #UDisksDrive:optical property.
 * @get_optical_blank: Getter for the #UDisksDrive:optical-blank property.
 * @get_optical_num_audio_tracks: Getter for the #UDisksDrive:optical-num-audio-tracks property.
 * @get_optical_num_data_tracks: Getter for the #UDisksDrive:optical-num-data-tracks property.
 * @get_optical_num_sessions: Getter for the #UDisksDrive:optical-num-sessions property.
 * @get_optical_num_tracks: Getter for the #UDisksDrive:optical-num-tracks property.
 * @get_removable: Getter for the #UDisksDrive:removable property.
 * @get_revision: Getter for the #UDisksDrive:revision property.
 * @get_rotation_rate: Getter for the #UDisksDrive:rotation-rate property.
 * @get_seat: Getter for the #UDisksDrive:seat property.
 * @get_serial: Getter for the #UDisksDrive:serial property.
 * @get_sibling_id: Getter for the #UDisksDrive:sibling-id property.
 * @get_size: Getter for the #UDisksDrive:size property.
 * @get_sort_key: Getter for the #UDisksDrive:sort-key property.
 * @get_time_detected: Getter for the #UDisksDrive:time-detected property.
 * @get_time_media_detected: Getter for the #UDisksDrive:time-media-detected property.
 * @get_vendor: Getter for the #UDisksDrive:vendor property.
 * @get_wwn: Getter for the #UDisksDrive:wwn property.
 * @handle_power_off: Handler for the #UDisksDrive::handle-power-off signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive.top_of_page">org.freedesktop.UDisks2.Drive</link>.
 */

typedef UDisksDriveIface UDisksDriveInterface;
G_DEFINE_INTERFACE (UDisksDrive, udisks_drive, G_TYPE_OBJECT)

static void
udisks_drive_default_init (UDisksDriveIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksDrive::handle-eject:
   * @object: A #UDisksDrive.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive.Eject">Eject()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_drive_complete_eject() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-eject",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksDriveIface, handle_eject),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_drive_method_marshal_eject,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksDrive::handle-set-configuration:
   * @object: A #UDisksDrive.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_value: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive.SetConfiguration">SetConfiguration()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_drive_complete_set_configuration() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-set-configuration",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksDriveIface, handle_set_configuration),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_drive_method_marshal_set_configuration,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT, G_TYPE_VARIANT);

  /**
   * UDisksDrive::handle-power-off:
   * @object: A #UDisksDrive.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive.PowerOff">PowerOff()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_drive_complete_power_off() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-power-off",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksDriveIface, handle_power_off),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_drive_method_marshal_power_off,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksDrive:vendor:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Vendor">"Vendor"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("vendor", "Vendor", "Vendor", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:model:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Model">"Model"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("model", "Model", "Model", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:revision:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Revision">"Revision"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("revision", "Revision", "Revision", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:serial:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Serial">"Serial"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("serial", "Serial", "Serial", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:wwn:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.WWN">"WWN"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("wwn", "WWN", "WWN", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:id:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Id">"Id"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("id", "Id", "Id", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:configuration:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Configuration">"Configuration"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_variant ("configuration", "Configuration", "Configuration", G_VARIANT_TYPE ("a{sv}"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:media:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Media">"Media"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("media", "Media", "Media", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:media-compatibility:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.MediaCompatibility">"MediaCompatibility"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boxed ("media-compatibility", "MediaCompatibility", "MediaCompatibility", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:media-removable:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.MediaRemovable">"MediaRemovable"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("media-removable", "MediaRemovable", "MediaRemovable", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:media-available:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.MediaAvailable">"MediaAvailable"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("media-available", "MediaAvailable", "MediaAvailable", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:media-change-detected:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.MediaChangeDetected">"MediaChangeDetected"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("media-change-detected", "MediaChangeDetected", "MediaChangeDetected", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Size">"Size"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("size", "Size", "Size", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:time-detected:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.TimeDetected">"TimeDetected"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("time-detected", "TimeDetected", "TimeDetected", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:time-media-detected:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.TimeMediaDetected">"TimeMediaDetected"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("time-media-detected", "TimeMediaDetected", "TimeMediaDetected", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:optical:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Optical">"Optical"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("optical", "Optical", "Optical", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:optical-blank:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalBlank">"OpticalBlank"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("optical-blank", "OpticalBlank", "OpticalBlank", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:optical-num-tracks:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalNumTracks">"OpticalNumTracks"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint ("optical-num-tracks", "OpticalNumTracks", "OpticalNumTracks", 0, G_MAXUINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:optical-num-audio-tracks:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalNumAudioTracks">"OpticalNumAudioTracks"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint ("optical-num-audio-tracks", "OpticalNumAudioTracks", "OpticalNumAudioTracks", 0, G_MAXUINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:optical-num-data-tracks:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalNumDataTracks">"OpticalNumDataTracks"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint ("optical-num-data-tracks", "OpticalNumDataTracks", "OpticalNumDataTracks", 0, G_MAXUINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:optical-num-sessions:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalNumSessions">"OpticalNumSessions"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint ("optical-num-sessions", "OpticalNumSessions", "OpticalNumSessions", 0, G_MAXUINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:rotation-rate:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.RotationRate">"RotationRate"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_int ("rotation-rate", "RotationRate", "RotationRate", G_MININT32, G_MAXINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:connection-bus:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.ConnectionBus">"ConnectionBus"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("connection-bus", "ConnectionBus", "ConnectionBus", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:seat:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Seat">"Seat"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("seat", "Seat", "Seat", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:removable:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Removable">"Removable"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("removable", "Removable", "Removable", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:ejectable:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Ejectable">"Ejectable"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("ejectable", "Ejectable", "Ejectable", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:sort-key:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.SortKey">"SortKey"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("sort-key", "SortKey", "SortKey", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:can-power-off:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.CanPowerOff">"CanPowerOff"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("can-power-off", "CanPowerOff", "CanPowerOff", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDrive:sibling-id:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.SiblingId">"SiblingId"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("sibling-id", "SiblingId", "SiblingId", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_drive_get_vendor: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Vendor">"Vendor"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_dup_vendor() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_drive_get_vendor (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), NULL);

  return UDISKS_DRIVE_GET_IFACE (object)->get_vendor (object);
}

/**
 * udisks_drive_dup_vendor: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Vendor">"Vendor"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_drive_dup_vendor (UDisksDrive *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "vendor", &value, NULL);
  return value;
}

/**
 * udisks_drive_set_vendor: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Vendor">"Vendor"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_vendor (UDisksDrive *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "vendor", value, NULL);
}

/**
 * udisks_drive_get_model: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Model">"Model"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_dup_model() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_drive_get_model (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), NULL);

  return UDISKS_DRIVE_GET_IFACE (object)->get_model (object);
}

/**
 * udisks_drive_dup_model: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Model">"Model"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_drive_dup_model (UDisksDrive *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "model", &value, NULL);
  return value;
}

/**
 * udisks_drive_set_model: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Model">"Model"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_model (UDisksDrive *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "model", value, NULL);
}

/**
 * udisks_drive_get_revision: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Revision">"Revision"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_dup_revision() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_drive_get_revision (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), NULL);

  return UDISKS_DRIVE_GET_IFACE (object)->get_revision (object);
}

/**
 * udisks_drive_dup_revision: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Revision">"Revision"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_drive_dup_revision (UDisksDrive *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "revision", &value, NULL);
  return value;
}

/**
 * udisks_drive_set_revision: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Revision">"Revision"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_revision (UDisksDrive *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "revision", value, NULL);
}

/**
 * udisks_drive_get_serial: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Serial">"Serial"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_dup_serial() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_drive_get_serial (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), NULL);

  return UDISKS_DRIVE_GET_IFACE (object)->get_serial (object);
}

/**
 * udisks_drive_dup_serial: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Serial">"Serial"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_drive_dup_serial (UDisksDrive *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "serial", &value, NULL);
  return value;
}

/**
 * udisks_drive_set_serial: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Serial">"Serial"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_serial (UDisksDrive *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "serial", value, NULL);
}

/**
 * udisks_drive_get_wwn: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.WWN">"WWN"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_dup_wwn() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_drive_get_wwn (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), NULL);

  return UDISKS_DRIVE_GET_IFACE (object)->get_wwn (object);
}

/**
 * udisks_drive_dup_wwn: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.WWN">"WWN"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_drive_dup_wwn (UDisksDrive *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "wwn", &value, NULL);
  return value;
}

/**
 * udisks_drive_set_wwn: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.WWN">"WWN"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_wwn (UDisksDrive *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "wwn", value, NULL);
}

/**
 * udisks_drive_get_id: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Id">"Id"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_dup_id() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_drive_get_id (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), NULL);

  return UDISKS_DRIVE_GET_IFACE (object)->get_id (object);
}

/**
 * udisks_drive_dup_id: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Id">"Id"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_drive_dup_id (UDisksDrive *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "id", &value, NULL);
  return value;
}

/**
 * udisks_drive_set_id: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Id">"Id"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_id (UDisksDrive *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "id", value, NULL);
}

/**
 * udisks_drive_get_configuration: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Configuration">"Configuration"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_dup_configuration() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
GVariant *
udisks_drive_get_configuration (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), NULL);

  return UDISKS_DRIVE_GET_IFACE (object)->get_configuration (object);
}

/**
 * udisks_drive_dup_configuration: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Configuration">"Configuration"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_variant_unref().
 */
GVariant *
udisks_drive_dup_configuration (UDisksDrive *object)
{
  GVariant *value;
  g_object_get (G_OBJECT (object), "configuration", &value, NULL);
  return value;
}

/**
 * udisks_drive_set_configuration: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Configuration">"Configuration"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_configuration (UDisksDrive *object, GVariant *value)
{
  g_object_set (G_OBJECT (object), "configuration", value, NULL);
}

/**
 * udisks_drive_get_media: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Media">"Media"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_dup_media() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_drive_get_media (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), NULL);

  return UDISKS_DRIVE_GET_IFACE (object)->get_media (object);
}

/**
 * udisks_drive_dup_media: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Media">"Media"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_drive_dup_media (UDisksDrive *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "media", &value, NULL);
  return value;
}

/**
 * udisks_drive_set_media: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Media">"Media"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_media (UDisksDrive *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "media", value, NULL);
}

/**
 * udisks_drive_get_media_compatibility: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.MediaCompatibility">"MediaCompatibility"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_dup_media_compatibility() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *const *
udisks_drive_get_media_compatibility (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), NULL);

  return UDISKS_DRIVE_GET_IFACE (object)->get_media_compatibility (object);
}

/**
 * udisks_drive_dup_media_compatibility: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.MediaCompatibility">"MediaCompatibility"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_strfreev().
 */
gchar **
udisks_drive_dup_media_compatibility (UDisksDrive *object)
{
  gchar **value;
  g_object_get (G_OBJECT (object), "media-compatibility", &value, NULL);
  return value;
}

/**
 * udisks_drive_set_media_compatibility: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.MediaCompatibility">"MediaCompatibility"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_media_compatibility (UDisksDrive *object, const gchar *const *value)
{
  g_object_set (G_OBJECT (object), "media-compatibility", value, NULL);
}

/**
 * udisks_drive_get_media_removable: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.MediaRemovable">"MediaRemovable"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_get_media_removable (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), FALSE);

  return UDISKS_DRIVE_GET_IFACE (object)->get_media_removable (object);
}

/**
 * udisks_drive_set_media_removable: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.MediaRemovable">"MediaRemovable"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_media_removable (UDisksDrive *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "media-removable", value, NULL);
}

/**
 * udisks_drive_get_media_available: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.MediaAvailable">"MediaAvailable"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_get_media_available (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), FALSE);

  return UDISKS_DRIVE_GET_IFACE (object)->get_media_available (object);
}

/**
 * udisks_drive_set_media_available: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.MediaAvailable">"MediaAvailable"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_media_available (UDisksDrive *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "media-available", value, NULL);
}

/**
 * udisks_drive_get_media_change_detected: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.MediaChangeDetected">"MediaChangeDetected"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_get_media_change_detected (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), FALSE);

  return UDISKS_DRIVE_GET_IFACE (object)->get_media_change_detected (object);
}

/**
 * udisks_drive_set_media_change_detected: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.MediaChangeDetected">"MediaChangeDetected"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_media_change_detected (UDisksDrive *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "media-change-detected", value, NULL);
}

/**
 * udisks_drive_get_size: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Size">"Size"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_drive_get_size (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), 0);

  return UDISKS_DRIVE_GET_IFACE (object)->get_size (object);
}

/**
 * udisks_drive_set_size: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Size">"Size"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_size (UDisksDrive *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "size", value, NULL);
}

/**
 * udisks_drive_get_time_detected: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.TimeDetected">"TimeDetected"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_drive_get_time_detected (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), 0);

  return UDISKS_DRIVE_GET_IFACE (object)->get_time_detected (object);
}

/**
 * udisks_drive_set_time_detected: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.TimeDetected">"TimeDetected"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_time_detected (UDisksDrive *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "time-detected", value, NULL);
}

/**
 * udisks_drive_get_time_media_detected: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.TimeMediaDetected">"TimeMediaDetected"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_drive_get_time_media_detected (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), 0);

  return UDISKS_DRIVE_GET_IFACE (object)->get_time_media_detected (object);
}

/**
 * udisks_drive_set_time_media_detected: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.TimeMediaDetected">"TimeMediaDetected"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_time_media_detected (UDisksDrive *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "time-media-detected", value, NULL);
}

/**
 * udisks_drive_get_optical: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Optical">"Optical"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_get_optical (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), FALSE);

  return UDISKS_DRIVE_GET_IFACE (object)->get_optical (object);
}

/**
 * udisks_drive_set_optical: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Optical">"Optical"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_optical (UDisksDrive *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "optical", value, NULL);
}

/**
 * udisks_drive_get_optical_blank: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalBlank">"OpticalBlank"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_get_optical_blank (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), FALSE);

  return UDISKS_DRIVE_GET_IFACE (object)->get_optical_blank (object);
}

/**
 * udisks_drive_set_optical_blank: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalBlank">"OpticalBlank"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_optical_blank (UDisksDrive *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "optical-blank", value, NULL);
}

/**
 * udisks_drive_get_optical_num_tracks: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalNumTracks">"OpticalNumTracks"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint 
udisks_drive_get_optical_num_tracks (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), 0);

  return UDISKS_DRIVE_GET_IFACE (object)->get_optical_num_tracks (object);
}

/**
 * udisks_drive_set_optical_num_tracks: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalNumTracks">"OpticalNumTracks"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_optical_num_tracks (UDisksDrive *object, guint value)
{
  g_object_set (G_OBJECT (object), "optical-num-tracks", value, NULL);
}

/**
 * udisks_drive_get_optical_num_audio_tracks: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalNumAudioTracks">"OpticalNumAudioTracks"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint 
udisks_drive_get_optical_num_audio_tracks (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), 0);

  return UDISKS_DRIVE_GET_IFACE (object)->get_optical_num_audio_tracks (object);
}

/**
 * udisks_drive_set_optical_num_audio_tracks: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalNumAudioTracks">"OpticalNumAudioTracks"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_optical_num_audio_tracks (UDisksDrive *object, guint value)
{
  g_object_set (G_OBJECT (object), "optical-num-audio-tracks", value, NULL);
}

/**
 * udisks_drive_get_optical_num_data_tracks: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalNumDataTracks">"OpticalNumDataTracks"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint 
udisks_drive_get_optical_num_data_tracks (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), 0);

  return UDISKS_DRIVE_GET_IFACE (object)->get_optical_num_data_tracks (object);
}

/**
 * udisks_drive_set_optical_num_data_tracks: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalNumDataTracks">"OpticalNumDataTracks"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_optical_num_data_tracks (UDisksDrive *object, guint value)
{
  g_object_set (G_OBJECT (object), "optical-num-data-tracks", value, NULL);
}

/**
 * udisks_drive_get_optical_num_sessions: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalNumSessions">"OpticalNumSessions"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint 
udisks_drive_get_optical_num_sessions (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), 0);

  return UDISKS_DRIVE_GET_IFACE (object)->get_optical_num_sessions (object);
}

/**
 * udisks_drive_set_optical_num_sessions: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.OpticalNumSessions">"OpticalNumSessions"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_optical_num_sessions (UDisksDrive *object, guint value)
{
  g_object_set (G_OBJECT (object), "optical-num-sessions", value, NULL);
}

/**
 * udisks_drive_get_rotation_rate: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.RotationRate">"RotationRate"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gint 
udisks_drive_get_rotation_rate (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), 0);

  return UDISKS_DRIVE_GET_IFACE (object)->get_rotation_rate (object);
}

/**
 * udisks_drive_set_rotation_rate: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.RotationRate">"RotationRate"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_rotation_rate (UDisksDrive *object, gint value)
{
  g_object_set (G_OBJECT (object), "rotation-rate", value, NULL);
}

/**
 * udisks_drive_get_connection_bus: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.ConnectionBus">"ConnectionBus"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_dup_connection_bus() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_drive_get_connection_bus (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), NULL);

  return UDISKS_DRIVE_GET_IFACE (object)->get_connection_bus (object);
}

/**
 * udisks_drive_dup_connection_bus: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.ConnectionBus">"ConnectionBus"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_drive_dup_connection_bus (UDisksDrive *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "connection-bus", &value, NULL);
  return value;
}

/**
 * udisks_drive_set_connection_bus: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.ConnectionBus">"ConnectionBus"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_connection_bus (UDisksDrive *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "connection-bus", value, NULL);
}

/**
 * udisks_drive_get_seat: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Seat">"Seat"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_dup_seat() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_drive_get_seat (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), NULL);

  return UDISKS_DRIVE_GET_IFACE (object)->get_seat (object);
}

/**
 * udisks_drive_dup_seat: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Seat">"Seat"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_drive_dup_seat (UDisksDrive *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "seat", &value, NULL);
  return value;
}

/**
 * udisks_drive_set_seat: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Seat">"Seat"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_seat (UDisksDrive *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "seat", value, NULL);
}

/**
 * udisks_drive_get_removable: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Removable">"Removable"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_get_removable (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), FALSE);

  return UDISKS_DRIVE_GET_IFACE (object)->get_removable (object);
}

/**
 * udisks_drive_set_removable: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Removable">"Removable"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_removable (UDisksDrive *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "removable", value, NULL);
}

/**
 * udisks_drive_get_ejectable: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Ejectable">"Ejectable"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_get_ejectable (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), FALSE);

  return UDISKS_DRIVE_GET_IFACE (object)->get_ejectable (object);
}

/**
 * udisks_drive_set_ejectable: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.Ejectable">"Ejectable"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_ejectable (UDisksDrive *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "ejectable", value, NULL);
}

/**
 * udisks_drive_get_sort_key: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.SortKey">"SortKey"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_dup_sort_key() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_drive_get_sort_key (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), NULL);

  return UDISKS_DRIVE_GET_IFACE (object)->get_sort_key (object);
}

/**
 * udisks_drive_dup_sort_key: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.SortKey">"SortKey"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_drive_dup_sort_key (UDisksDrive *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "sort-key", &value, NULL);
  return value;
}

/**
 * udisks_drive_set_sort_key: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.SortKey">"SortKey"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_sort_key (UDisksDrive *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "sort-key", value, NULL);
}

/**
 * udisks_drive_get_can_power_off: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.CanPowerOff">"CanPowerOff"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_get_can_power_off (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), FALSE);

  return UDISKS_DRIVE_GET_IFACE (object)->get_can_power_off (object);
}

/**
 * udisks_drive_set_can_power_off: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.CanPowerOff">"CanPowerOff"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_can_power_off (UDisksDrive *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "can-power-off", value, NULL);
}

/**
 * udisks_drive_get_sibling_id: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.SiblingId">"SiblingId"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_dup_sibling_id() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_drive_get_sibling_id (UDisksDrive *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE (object), NULL);

  return UDISKS_DRIVE_GET_IFACE (object)->get_sibling_id (object);
}

/**
 * udisks_drive_dup_sibling_id: (skip)
 * @object: A #UDisksDrive.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.SiblingId">"SiblingId"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_drive_dup_sibling_id (UDisksDrive *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "sibling-id", &value, NULL);
  return value;
}

/**
 * udisks_drive_set_sibling_id: (skip)
 * @object: A #UDisksDrive.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive.SiblingId">"SiblingId"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_set_sibling_id (UDisksDrive *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "sibling-id", value, NULL);
}

/**
 * udisks_drive_call_eject:
 * @proxy: A #UDisksDriveProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive.Eject">Eject()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_call_eject_finish() to get the result of the operation.
 *
 * See udisks_drive_call_eject_sync() for the synchronous, blocking version of this method.
 */
void
udisks_drive_call_eject (
    UDisksDrive *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Eject",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_drive_call_eject_finish:
 * @proxy: A #UDisksDriveProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_call_eject().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_drive_call_eject().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_call_eject_finish (
    UDisksDrive *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_call_eject_sync:
 * @proxy: A #UDisksDriveProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive.Eject">Eject()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_call_eject() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_call_eject_sync (
    UDisksDrive *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Eject",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_call_set_configuration:
 * @proxy: A #UDisksDriveProxy.
 * @arg_value: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive.SetConfiguration">SetConfiguration()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_call_set_configuration_finish() to get the result of the operation.
 *
 * See udisks_drive_call_set_configuration_sync() for the synchronous, blocking version of this method.
 */
void
udisks_drive_call_set_configuration (
    UDisksDrive *proxy,
    GVariant *arg_value,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetConfiguration",
    g_variant_new ("(@a{sv}@a{sv})",
                   arg_value,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_drive_call_set_configuration_finish:
 * @proxy: A #UDisksDriveProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_call_set_configuration().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_drive_call_set_configuration().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_call_set_configuration_finish (
    UDisksDrive *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_call_set_configuration_sync:
 * @proxy: A #UDisksDriveProxy.
 * @arg_value: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive.SetConfiguration">SetConfiguration()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_call_set_configuration() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_call_set_configuration_sync (
    UDisksDrive *proxy,
    GVariant *arg_value,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetConfiguration",
    g_variant_new ("(@a{sv}@a{sv})",
                   arg_value,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_call_power_off:
 * @proxy: A #UDisksDriveProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive.PowerOff">PowerOff()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_call_power_off_finish() to get the result of the operation.
 *
 * See udisks_drive_call_power_off_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_drive_call_power_off (
    UDisksDrive *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "PowerOff",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_drive_call_power_off_finish:
 * @proxy: A #UDisksDriveProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_call_power_off().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_drive_call_power_off().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_drive_call_power_off_finish (
    UDisksDrive *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_call_power_off_sync:
 * @proxy: A #UDisksDriveProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive.PowerOff">PowerOff()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_call_power_off() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_drive_call_power_off_sync (
    UDisksDrive *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "PowerOff",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_complete_eject:
 * @object: A #UDisksDrive.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive.Eject">Eject()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_drive_complete_eject (
    UDisksDrive *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_drive_complete_set_configuration:
 * @object: A #UDisksDrive.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive.SetConfiguration">SetConfiguration()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_drive_complete_set_configuration (
    UDisksDrive *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_drive_complete_power_off:
 * @object: A #UDisksDrive.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive.PowerOff">PowerOff()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_drive_complete_power_off (
    UDisksDrive *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksDriveProxy:
 *
 * The #UDisksDriveProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksDriveProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksDriveProxy.
 */

struct _UDisksDriveProxyPrivate
{
  GData *qdata;
};

static void udisks_drive_proxy_iface_init (UDisksDriveIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksDriveProxy, udisks_drive_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksDriveProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_DRIVE, udisks_drive_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksDriveProxy, udisks_drive_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_DRIVE, udisks_drive_proxy_iface_init))

#endif
static void
udisks_drive_proxy_finalize (GObject *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_drive_proxy_parent_class)->finalize (object);
}

static void
udisks_drive_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 29);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_drive_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_drive_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.Drive: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_drive_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 29);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_drive_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.Drive", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_drive_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_drive_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_drive_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_DRIVE);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_DRIVE);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_drive_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_drive_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_drive_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_drive_proxy_get_vendor (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Vendor");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_drive_proxy_get_model (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Model");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_drive_proxy_get_revision (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Revision");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_drive_proxy_get_serial (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Serial");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_drive_proxy_get_wwn (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "WWN");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_drive_proxy_get_id (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Id");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static GVariant *
udisks_drive_proxy_get_configuration (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  GVariant *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Configuration");
  value = variant;
  if (variant != NULL)
    g_variant_unref (variant);
  return value;
}

static const gchar *
udisks_drive_proxy_get_media (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Media");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *const *
udisks_drive_proxy_get_media_compatibility (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  const gchar *const *value = NULL;
  value = g_datalist_get_data (&proxy->priv->qdata, "MediaCompatibility");
  if (value != NULL)
    return value;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "MediaCompatibility");
  if (variant != NULL)
    {
      value = g_variant_get_strv (variant, NULL);
      g_datalist_set_data_full (&proxy->priv->qdata, "MediaCompatibility", (gpointer) value, g_free);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_proxy_get_media_removable (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "MediaRemovable");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_proxy_get_media_available (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "MediaAvailable");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_proxy_get_media_change_detected (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "MediaChangeDetected");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_drive_proxy_get_size (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Size");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_drive_proxy_get_time_detected (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "TimeDetected");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_drive_proxy_get_time_media_detected (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "TimeMediaDetected");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_proxy_get_optical (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Optical");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_proxy_get_optical_blank (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "OpticalBlank");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint 
udisks_drive_proxy_get_optical_num_tracks (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  guint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "OpticalNumTracks");
  if (variant != NULL)
    {
      value = g_variant_get_uint32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint 
udisks_drive_proxy_get_optical_num_audio_tracks (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  guint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "OpticalNumAudioTracks");
  if (variant != NULL)
    {
      value = g_variant_get_uint32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint 
udisks_drive_proxy_get_optical_num_data_tracks (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  guint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "OpticalNumDataTracks");
  if (variant != NULL)
    {
      value = g_variant_get_uint32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint 
udisks_drive_proxy_get_optical_num_sessions (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  guint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "OpticalNumSessions");
  if (variant != NULL)
    {
      value = g_variant_get_uint32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gint 
udisks_drive_proxy_get_rotation_rate (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  gint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "RotationRate");
  if (variant != NULL)
    {
      value = g_variant_get_int32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_drive_proxy_get_connection_bus (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ConnectionBus");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_drive_proxy_get_seat (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Seat");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_proxy_get_removable (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Removable");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_proxy_get_ejectable (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Ejectable");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_drive_proxy_get_sort_key (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SortKey");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_proxy_get_can_power_off (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "CanPowerOff");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_drive_proxy_get_sibling_id (UDisksDrive *object)
{
  UDisksDriveProxy *proxy = UDISKS_DRIVE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SiblingId");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_drive_proxy_init (UDisksDriveProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_drive_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_DRIVE_PROXY, UDisksDriveProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_drive_interface_info ());
}

static void
udisks_drive_proxy_class_init (UDisksDriveProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_drive_proxy_finalize;
  gobject_class->get_property = udisks_drive_proxy_get_property;
  gobject_class->set_property = udisks_drive_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_drive_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_drive_proxy_g_properties_changed;

  udisks_drive_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksDriveProxyPrivate));
#endif
}

static void
udisks_drive_proxy_iface_init (UDisksDriveIface *iface)
{
  iface->get_vendor = udisks_drive_proxy_get_vendor;
  iface->get_model = udisks_drive_proxy_get_model;
  iface->get_revision = udisks_drive_proxy_get_revision;
  iface->get_serial = udisks_drive_proxy_get_serial;
  iface->get_wwn = udisks_drive_proxy_get_wwn;
  iface->get_id = udisks_drive_proxy_get_id;
  iface->get_configuration = udisks_drive_proxy_get_configuration;
  iface->get_media = udisks_drive_proxy_get_media;
  iface->get_media_compatibility = udisks_drive_proxy_get_media_compatibility;
  iface->get_media_removable = udisks_drive_proxy_get_media_removable;
  iface->get_media_available = udisks_drive_proxy_get_media_available;
  iface->get_media_change_detected = udisks_drive_proxy_get_media_change_detected;
  iface->get_size = udisks_drive_proxy_get_size;
  iface->get_time_detected = udisks_drive_proxy_get_time_detected;
  iface->get_time_media_detected = udisks_drive_proxy_get_time_media_detected;
  iface->get_optical = udisks_drive_proxy_get_optical;
  iface->get_optical_blank = udisks_drive_proxy_get_optical_blank;
  iface->get_optical_num_tracks = udisks_drive_proxy_get_optical_num_tracks;
  iface->get_optical_num_audio_tracks = udisks_drive_proxy_get_optical_num_audio_tracks;
  iface->get_optical_num_data_tracks = udisks_drive_proxy_get_optical_num_data_tracks;
  iface->get_optical_num_sessions = udisks_drive_proxy_get_optical_num_sessions;
  iface->get_rotation_rate = udisks_drive_proxy_get_rotation_rate;
  iface->get_connection_bus = udisks_drive_proxy_get_connection_bus;
  iface->get_seat = udisks_drive_proxy_get_seat;
  iface->get_removable = udisks_drive_proxy_get_removable;
  iface->get_ejectable = udisks_drive_proxy_get_ejectable;
  iface->get_sort_key = udisks_drive_proxy_get_sort_key;
  iface->get_can_power_off = udisks_drive_proxy_get_can_power_off;
  iface->get_sibling_id = udisks_drive_proxy_get_sibling_id;
}

/**
 * udisks_drive_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive.top_of_page">org.freedesktop.UDisks2.Drive</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_drive_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_drive_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_DRIVE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Drive", NULL);
}

/**
 * udisks_drive_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_drive_proxy_new().
 *
 * Returns: (transfer full) (type UDisksDriveProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksDrive *
udisks_drive_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_DRIVE (ret);
  else
    return NULL;
}

/**
 * udisks_drive_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive.top_of_page">org.freedesktop.UDisks2.Drive</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksDriveProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksDrive *
udisks_drive_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_DRIVE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Drive", NULL);
  if (ret != NULL)
    return UDISKS_DRIVE (ret);
  else
    return NULL;
}


/**
 * udisks_drive_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_drive_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_drive_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_drive_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_DRIVE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Drive", NULL);
}

/**
 * udisks_drive_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_drive_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksDriveProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksDrive *
udisks_drive_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_DRIVE (ret);
  else
    return NULL;
}

/**
 * udisks_drive_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_drive_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksDriveProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksDrive *
udisks_drive_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_DRIVE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Drive", NULL);
  if (ret != NULL)
    return UDISKS_DRIVE (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksDriveSkeleton:
 *
 * The #UDisksDriveSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksDriveSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksDriveSkeleton.
 */

struct _UDisksDriveSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_drive_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_DRIVE);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_DRIVE);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_drive_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_drive_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_drive_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_drive_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_drive_skeleton_vtable =
{
  _udisks_drive_skeleton_handle_method_call,
  _udisks_drive_skeleton_handle_get_property,
  _udisks_drive_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_drive_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_drive_interface_info ();
}

static GDBusInterfaceVTable *
udisks_drive_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_drive_skeleton_vtable;
}

static GVariant *
udisks_drive_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_drive_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_drive_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_drive_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_drive_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Drive", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_drive_emit_changed (gpointer user_data);

static void
udisks_drive_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_drive_emit_changed (skeleton);
}

static void udisks_drive_skeleton_iface_init (UDisksDriveIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksDriveSkeleton, udisks_drive_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksDriveSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_DRIVE, udisks_drive_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksDriveSkeleton, udisks_drive_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_DRIVE, udisks_drive_skeleton_iface_init))

#endif
static void
udisks_drive_skeleton_finalize (GObject *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  guint n;
  for (n = 0; n < 29; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_drive_skeleton_parent_class)->finalize (object);
}

static void
udisks_drive_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 29);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_drive_emit_changed (gpointer user_data)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.Drive",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_drive_schedule_emit_changed (UDisksDriveSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_drive_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_drive_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_drive_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_drive_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 29);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_drive_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_drive_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_drive_skeleton_init (UDisksDriveSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_drive_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_DRIVE_SKELETON, UDisksDriveSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 29);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[4], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[5], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[6], G_TYPE_VARIANT);
  g_value_init (&skeleton->priv->properties[7], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[8], G_TYPE_STRV);
  g_value_init (&skeleton->priv->properties[9], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[10], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[11], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[12], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[13], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[14], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[15], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[16], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[17], G_TYPE_UINT);
  g_value_init (&skeleton->priv->properties[18], G_TYPE_UINT);
  g_value_init (&skeleton->priv->properties[19], G_TYPE_UINT);
  g_value_init (&skeleton->priv->properties[20], G_TYPE_UINT);
  g_value_init (&skeleton->priv->properties[21], G_TYPE_INT);
  g_value_init (&skeleton->priv->properties[22], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[23], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[24], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[25], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[26], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[27], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[28], G_TYPE_STRING);
}

static const gchar *
udisks_drive_skeleton_get_vendor (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_drive_skeleton_get_model (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_drive_skeleton_get_revision (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_drive_skeleton_get_serial (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_drive_skeleton_get_wwn (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[4]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_drive_skeleton_get_id (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[5]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static GVariant *
udisks_drive_skeleton_get_configuration (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  GVariant *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_variant (&(skeleton->priv->properties[6]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_drive_skeleton_get_media (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[7]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *const *
udisks_drive_skeleton_get_media_compatibility (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  const gchar *const *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boxed (&(skeleton->priv->properties[8]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_skeleton_get_media_removable (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[9]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_skeleton_get_media_available (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[10]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_skeleton_get_media_change_detected (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[11]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_drive_skeleton_get_size (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[12]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_drive_skeleton_get_time_detected (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[13]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_drive_skeleton_get_time_media_detected (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[14]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_skeleton_get_optical (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[15]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_skeleton_get_optical_blank (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[16]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint 
udisks_drive_skeleton_get_optical_num_tracks (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  guint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint (&(skeleton->priv->properties[17]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint 
udisks_drive_skeleton_get_optical_num_audio_tracks (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  guint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint (&(skeleton->priv->properties[18]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint 
udisks_drive_skeleton_get_optical_num_data_tracks (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  guint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint (&(skeleton->priv->properties[19]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint 
udisks_drive_skeleton_get_optical_num_sessions (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  guint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint (&(skeleton->priv->properties[20]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gint 
udisks_drive_skeleton_get_rotation_rate (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  gint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_int (&(skeleton->priv->properties[21]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_drive_skeleton_get_connection_bus (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[22]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_drive_skeleton_get_seat (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[23]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_skeleton_get_removable (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[24]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_skeleton_get_ejectable (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[25]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_drive_skeleton_get_sort_key (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[26]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_skeleton_get_can_power_off (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[27]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_drive_skeleton_get_sibling_id (UDisksDrive *object)
{
  UDisksDriveSkeleton *skeleton = UDISKS_DRIVE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[28]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_drive_skeleton_class_init (UDisksDriveSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_drive_skeleton_finalize;
  gobject_class->get_property = udisks_drive_skeleton_get_property;
  gobject_class->set_property = udisks_drive_skeleton_set_property;
  gobject_class->notify       = udisks_drive_skeleton_notify;


  udisks_drive_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_drive_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_drive_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_drive_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_drive_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksDriveSkeletonPrivate));
#endif
}

static void
udisks_drive_skeleton_iface_init (UDisksDriveIface *iface)
{
  iface->get_vendor = udisks_drive_skeleton_get_vendor;
  iface->get_model = udisks_drive_skeleton_get_model;
  iface->get_revision = udisks_drive_skeleton_get_revision;
  iface->get_serial = udisks_drive_skeleton_get_serial;
  iface->get_wwn = udisks_drive_skeleton_get_wwn;
  iface->get_id = udisks_drive_skeleton_get_id;
  iface->get_configuration = udisks_drive_skeleton_get_configuration;
  iface->get_media = udisks_drive_skeleton_get_media;
  iface->get_media_compatibility = udisks_drive_skeleton_get_media_compatibility;
  iface->get_media_removable = udisks_drive_skeleton_get_media_removable;
  iface->get_media_available = udisks_drive_skeleton_get_media_available;
  iface->get_media_change_detected = udisks_drive_skeleton_get_media_change_detected;
  iface->get_size = udisks_drive_skeleton_get_size;
  iface->get_time_detected = udisks_drive_skeleton_get_time_detected;
  iface->get_time_media_detected = udisks_drive_skeleton_get_time_media_detected;
  iface->get_optical = udisks_drive_skeleton_get_optical;
  iface->get_optical_blank = udisks_drive_skeleton_get_optical_blank;
  iface->get_optical_num_tracks = udisks_drive_skeleton_get_optical_num_tracks;
  iface->get_optical_num_audio_tracks = udisks_drive_skeleton_get_optical_num_audio_tracks;
  iface->get_optical_num_data_tracks = udisks_drive_skeleton_get_optical_num_data_tracks;
  iface->get_optical_num_sessions = udisks_drive_skeleton_get_optical_num_sessions;
  iface->get_rotation_rate = udisks_drive_skeleton_get_rotation_rate;
  iface->get_connection_bus = udisks_drive_skeleton_get_connection_bus;
  iface->get_seat = udisks_drive_skeleton_get_seat;
  iface->get_removable = udisks_drive_skeleton_get_removable;
  iface->get_ejectable = udisks_drive_skeleton_get_ejectable;
  iface->get_sort_key = udisks_drive_skeleton_get_sort_key;
  iface->get_can_power_off = udisks_drive_skeleton_get_can_power_off;
  iface->get_sibling_id = udisks_drive_skeleton_get_sibling_id;
}

/**
 * udisks_drive_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive.top_of_page">org.freedesktop.UDisks2.Drive</link>.
 *
 * Returns: (transfer full) (type UDisksDriveSkeleton): The skeleton object.
 */
UDisksDrive *
udisks_drive_skeleton_new (void)
{
  return UDISKS_DRIVE (g_object_new (UDISKS_TYPE_DRIVE_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Drive.Ata
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksDriveAta
 * @title: UDisksDriveAta
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Drive.Ata D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive-Ata.top_of_page">org.freedesktop.UDisks2.Drive.Ata</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Drive.Ata ---- */

static const _ExtendedGDBusArgInfo _udisks_drive_ata_method_info_smart_update_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_ata_method_info_smart_update_IN_ARG_pointers[] =
{
  &_udisks_drive_ata_method_info_smart_update_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_drive_ata_method_info_smart_update =
{
  {
    -1,
    (gchar *) "SmartUpdate",
    (GDBusArgInfo **) &_udisks_drive_ata_method_info_smart_update_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-smart-update",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_drive_ata_method_info_smart_get_attributes_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_ata_method_info_smart_get_attributes_IN_ARG_pointers[] =
{
  &_udisks_drive_ata_method_info_smart_get_attributes_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_drive_ata_method_info_smart_get_attributes_OUT_ARG_attributes =
{
  {
    -1,
    (gchar *) "attributes",
    (gchar *) "a(ysqiiixia{sv})",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_ata_method_info_smart_get_attributes_OUT_ARG_pointers[] =
{
  &_udisks_drive_ata_method_info_smart_get_attributes_OUT_ARG_attributes.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_drive_ata_method_info_smart_get_attributes =
{
  {
    -1,
    (gchar *) "SmartGetAttributes",
    (GDBusArgInfo **) &_udisks_drive_ata_method_info_smart_get_attributes_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_drive_ata_method_info_smart_get_attributes_OUT_ARG_pointers,
    NULL
  },
  "handle-smart-get-attributes",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_drive_ata_method_info_smart_selftest_start_IN_ARG_type =
{
  {
    -1,
    (gchar *) "type",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_drive_ata_method_info_smart_selftest_start_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_ata_method_info_smart_selftest_start_IN_ARG_pointers[] =
{
  &_udisks_drive_ata_method_info_smart_selftest_start_IN_ARG_type.parent_struct,
  &_udisks_drive_ata_method_info_smart_selftest_start_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_drive_ata_method_info_smart_selftest_start =
{
  {
    -1,
    (gchar *) "SmartSelftestStart",
    (GDBusArgInfo **) &_udisks_drive_ata_method_info_smart_selftest_start_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-smart-selftest-start",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_drive_ata_method_info_smart_selftest_abort_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_ata_method_info_smart_selftest_abort_IN_ARG_pointers[] =
{
  &_udisks_drive_ata_method_info_smart_selftest_abort_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_drive_ata_method_info_smart_selftest_abort =
{
  {
    -1,
    (gchar *) "SmartSelftestAbort",
    (GDBusArgInfo **) &_udisks_drive_ata_method_info_smart_selftest_abort_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-smart-selftest-abort",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_drive_ata_method_info_smart_set_enabled_IN_ARG_value =
{
  {
    -1,
    (gchar *) "value",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_drive_ata_method_info_smart_set_enabled_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_ata_method_info_smart_set_enabled_IN_ARG_pointers[] =
{
  &_udisks_drive_ata_method_info_smart_set_enabled_IN_ARG_value.parent_struct,
  &_udisks_drive_ata_method_info_smart_set_enabled_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_drive_ata_method_info_smart_set_enabled =
{
  {
    -1,
    (gchar *) "SmartSetEnabled",
    (GDBusArgInfo **) &_udisks_drive_ata_method_info_smart_set_enabled_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-smart-set-enabled",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_drive_ata_method_info_pm_get_state_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_ata_method_info_pm_get_state_IN_ARG_pointers[] =
{
  &_udisks_drive_ata_method_info_pm_get_state_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_drive_ata_method_info_pm_get_state_OUT_ARG_state =
{
  {
    -1,
    (gchar *) "state",
    (gchar *) "y",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_ata_method_info_pm_get_state_OUT_ARG_pointers[] =
{
  &_udisks_drive_ata_method_info_pm_get_state_OUT_ARG_state.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_drive_ata_method_info_pm_get_state =
{
  {
    -1,
    (gchar *) "PmGetState",
    (GDBusArgInfo **) &_udisks_drive_ata_method_info_pm_get_state_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_drive_ata_method_info_pm_get_state_OUT_ARG_pointers,
    NULL
  },
  "handle-pm-get-state",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_drive_ata_method_info_pm_standby_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_ata_method_info_pm_standby_IN_ARG_pointers[] =
{
  &_udisks_drive_ata_method_info_pm_standby_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_drive_ata_method_info_pm_standby =
{
  {
    -1,
    (gchar *) "PmStandby",
    (GDBusArgInfo **) &_udisks_drive_ata_method_info_pm_standby_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-pm-standby",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_drive_ata_method_info_pm_wakeup_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_ata_method_info_pm_wakeup_IN_ARG_pointers[] =
{
  &_udisks_drive_ata_method_info_pm_wakeup_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_drive_ata_method_info_pm_wakeup =
{
  {
    -1,
    (gchar *) "PmWakeup",
    (GDBusArgInfo **) &_udisks_drive_ata_method_info_pm_wakeup_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-pm-wakeup",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_drive_ata_method_info_security_erase_unit_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_drive_ata_method_info_security_erase_unit_IN_ARG_pointers[] =
{
  &_udisks_drive_ata_method_info_security_erase_unit_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_drive_ata_method_info_security_erase_unit =
{
  {
    -1,
    (gchar *) "SecurityEraseUnit",
    (GDBusArgInfo **) &_udisks_drive_ata_method_info_security_erase_unit_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-security-erase-unit",
  FALSE
};

static const GDBusMethodInfo * const _udisks_drive_ata_method_info_pointers[] =
{
  &_udisks_drive_ata_method_info_smart_update.parent_struct,
  &_udisks_drive_ata_method_info_smart_get_attributes.parent_struct,
  &_udisks_drive_ata_method_info_smart_selftest_start.parent_struct,
  &_udisks_drive_ata_method_info_smart_selftest_abort.parent_struct,
  &_udisks_drive_ata_method_info_smart_set_enabled.parent_struct,
  &_udisks_drive_ata_method_info_pm_get_state.parent_struct,
  &_udisks_drive_ata_method_info_pm_standby.parent_struct,
  &_udisks_drive_ata_method_info_pm_wakeup.parent_struct,
  &_udisks_drive_ata_method_info_security_erase_unit.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_smart_supported =
{
  {
    -1,
    (gchar *) "SmartSupported",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-supported",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_smart_enabled =
{
  {
    -1,
    (gchar *) "SmartEnabled",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-enabled",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_smart_updated =
{
  {
    -1,
    (gchar *) "SmartUpdated",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-updated",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_smart_failing =
{
  {
    -1,
    (gchar *) "SmartFailing",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-failing",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_smart_power_on_seconds =
{
  {
    -1,
    (gchar *) "SmartPowerOnSeconds",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-power-on-seconds",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_smart_temperature =
{
  {
    -1,
    (gchar *) "SmartTemperature",
    (gchar *) "d",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-temperature",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_smart_num_attributes_failing =
{
  {
    -1,
    (gchar *) "SmartNumAttributesFailing",
    (gchar *) "i",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-num-attributes-failing",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_smart_num_attributes_failed_in_the_past =
{
  {
    -1,
    (gchar *) "SmartNumAttributesFailedInThePast",
    (gchar *) "i",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-num-attributes-failed-in-the-past",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_smart_num_bad_sectors =
{
  {
    -1,
    (gchar *) "SmartNumBadSectors",
    (gchar *) "x",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-num-bad-sectors",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_smart_selftest_status =
{
  {
    -1,
    (gchar *) "SmartSelftestStatus",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-selftest-status",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_smart_selftest_percent_remaining =
{
  {
    -1,
    (gchar *) "SmartSelftestPercentRemaining",
    (gchar *) "i",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-selftest-percent-remaining",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_pm_supported =
{
  {
    -1,
    (gchar *) "PmSupported",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "pm-supported",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_pm_enabled =
{
  {
    -1,
    (gchar *) "PmEnabled",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "pm-enabled",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_apm_supported =
{
  {
    -1,
    (gchar *) "ApmSupported",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "apm-supported",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_apm_enabled =
{
  {
    -1,
    (gchar *) "ApmEnabled",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "apm-enabled",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_aam_supported =
{
  {
    -1,
    (gchar *) "AamSupported",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "aam-supported",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_aam_enabled =
{
  {
    -1,
    (gchar *) "AamEnabled",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "aam-enabled",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_aam_vendor_recommended_value =
{
  {
    -1,
    (gchar *) "AamVendorRecommendedValue",
    (gchar *) "i",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "aam-vendor-recommended-value",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_write_cache_supported =
{
  {
    -1,
    (gchar *) "WriteCacheSupported",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "write-cache-supported",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_write_cache_enabled =
{
  {
    -1,
    (gchar *) "WriteCacheEnabled",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "write-cache-enabled",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_read_lookahead_supported =
{
  {
    -1,
    (gchar *) "ReadLookaheadSupported",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "read-lookahead-supported",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_read_lookahead_enabled =
{
  {
    -1,
    (gchar *) "ReadLookaheadEnabled",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "read-lookahead-enabled",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_security_erase_unit_minutes =
{
  {
    -1,
    (gchar *) "SecurityEraseUnitMinutes",
    (gchar *) "i",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "security-erase-unit-minutes",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_security_enhanced_erase_unit_minutes =
{
  {
    -1,
    (gchar *) "SecurityEnhancedEraseUnitMinutes",
    (gchar *) "i",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "security-enhanced-erase-unit-minutes",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_drive_ata_property_info_security_frozen =
{
  {
    -1,
    (gchar *) "SecurityFrozen",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "security-frozen",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_drive_ata_property_info_pointers[] =
{
  &_udisks_drive_ata_property_info_smart_supported.parent_struct,
  &_udisks_drive_ata_property_info_smart_enabled.parent_struct,
  &_udisks_drive_ata_property_info_smart_updated.parent_struct,
  &_udisks_drive_ata_property_info_smart_failing.parent_struct,
  &_udisks_drive_ata_property_info_smart_power_on_seconds.parent_struct,
  &_udisks_drive_ata_property_info_smart_temperature.parent_struct,
  &_udisks_drive_ata_property_info_smart_num_attributes_failing.parent_struct,
  &_udisks_drive_ata_property_info_smart_num_attributes_failed_in_the_past.parent_struct,
  &_udisks_drive_ata_property_info_smart_num_bad_sectors.parent_struct,
  &_udisks_drive_ata_property_info_smart_selftest_status.parent_struct,
  &_udisks_drive_ata_property_info_smart_selftest_percent_remaining.parent_struct,
  &_udisks_drive_ata_property_info_pm_supported.parent_struct,
  &_udisks_drive_ata_property_info_pm_enabled.parent_struct,
  &_udisks_drive_ata_property_info_apm_supported.parent_struct,
  &_udisks_drive_ata_property_info_apm_enabled.parent_struct,
  &_udisks_drive_ata_property_info_aam_supported.parent_struct,
  &_udisks_drive_ata_property_info_aam_enabled.parent_struct,
  &_udisks_drive_ata_property_info_aam_vendor_recommended_value.parent_struct,
  &_udisks_drive_ata_property_info_write_cache_supported.parent_struct,
  &_udisks_drive_ata_property_info_write_cache_enabled.parent_struct,
  &_udisks_drive_ata_property_info_read_lookahead_supported.parent_struct,
  &_udisks_drive_ata_property_info_read_lookahead_enabled.parent_struct,
  &_udisks_drive_ata_property_info_security_erase_unit_minutes.parent_struct,
  &_udisks_drive_ata_property_info_security_enhanced_erase_unit_minutes.parent_struct,
  &_udisks_drive_ata_property_info_security_frozen.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_drive_ata_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Drive.Ata",
    (GDBusMethodInfo **) &_udisks_drive_ata_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_drive_ata_property_info_pointers,
    NULL
  },
  "drive-ata",
};


/**
 * udisks_drive_ata_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive-Ata.top_of_page">org.freedesktop.UDisks2.Drive.Ata</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_drive_ata_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_drive_ata_interface_info.parent_struct;
}

/**
 * udisks_drive_ata_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksDriveAta interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_drive_ata_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "smart-supported");
  g_object_class_override_property (klass, property_id_begin++, "smart-enabled");
  g_object_class_override_property (klass, property_id_begin++, "smart-updated");
  g_object_class_override_property (klass, property_id_begin++, "smart-failing");
  g_object_class_override_property (klass, property_id_begin++, "smart-power-on-seconds");
  g_object_class_override_property (klass, property_id_begin++, "smart-temperature");
  g_object_class_override_property (klass, property_id_begin++, "smart-num-attributes-failing");
  g_object_class_override_property (klass, property_id_begin++, "smart-num-attributes-failed-in-the-past");
  g_object_class_override_property (klass, property_id_begin++, "smart-num-bad-sectors");
  g_object_class_override_property (klass, property_id_begin++, "smart-selftest-status");
  g_object_class_override_property (klass, property_id_begin++, "smart-selftest-percent-remaining");
  g_object_class_override_property (klass, property_id_begin++, "pm-supported");
  g_object_class_override_property (klass, property_id_begin++, "pm-enabled");
  g_object_class_override_property (klass, property_id_begin++, "apm-supported");
  g_object_class_override_property (klass, property_id_begin++, "apm-enabled");
  g_object_class_override_property (klass, property_id_begin++, "aam-supported");
  g_object_class_override_property (klass, property_id_begin++, "aam-enabled");
  g_object_class_override_property (klass, property_id_begin++, "aam-vendor-recommended-value");
  g_object_class_override_property (klass, property_id_begin++, "write-cache-supported");
  g_object_class_override_property (klass, property_id_begin++, "write-cache-enabled");
  g_object_class_override_property (klass, property_id_begin++, "read-lookahead-supported");
  g_object_class_override_property (klass, property_id_begin++, "read-lookahead-enabled");
  g_object_class_override_property (klass, property_id_begin++, "security-erase-unit-minutes");
  g_object_class_override_property (klass, property_id_begin++, "security-enhanced-erase-unit-minutes");
  g_object_class_override_property (klass, property_id_begin++, "security-frozen");
  return property_id_begin - 1;
}


inline static void
udisks_drive_ata_method_marshal_smart_update (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_drive_ata_method_marshal_smart_get_attributes (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_drive_ata_method_marshal_smart_selftest_start (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_drive_ata_method_marshal_smart_selftest_abort (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_drive_ata_method_marshal_smart_set_enabled (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOOLEAN_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_drive_ata_method_marshal_pm_get_state (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_drive_ata_method_marshal_pm_standby (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_drive_ata_method_marshal_pm_wakeup (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_drive_ata_method_marshal_security_erase_unit (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksDriveAta:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive-Ata.top_of_page">org.freedesktop.UDisks2.Drive.Ata</link>.
 */

/**
 * UDisksDriveAtaIface:
 * @parent_iface: The parent interface.
 * @handle_pm_get_state: Handler for the #UDisksDriveAta::handle-pm-get-state signal.
 * @handle_pm_standby: Handler for the #UDisksDriveAta::handle-pm-standby signal.
 * @handle_pm_wakeup: Handler for the #UDisksDriveAta::handle-pm-wakeup signal.
 * @handle_security_erase_unit: Handler for the #UDisksDriveAta::handle-security-erase-unit signal.
 * @handle_smart_get_attributes: Handler for the #UDisksDriveAta::handle-smart-get-attributes signal.
 * @handle_smart_selftest_abort: Handler for the #UDisksDriveAta::handle-smart-selftest-abort signal.
 * @handle_smart_selftest_start: Handler for the #UDisksDriveAta::handle-smart-selftest-start signal.
 * @handle_smart_update: Handler for the #UDisksDriveAta::handle-smart-update signal.
 * @get_aam_enabled: Getter for the #UDisksDriveAta:aam-enabled property.
 * @get_aam_supported: Getter for the #UDisksDriveAta:aam-supported property.
 * @get_aam_vendor_recommended_value: Getter for the #UDisksDriveAta:aam-vendor-recommended-value property.
 * @get_apm_enabled: Getter for the #UDisksDriveAta:apm-enabled property.
 * @get_apm_supported: Getter for the #UDisksDriveAta:apm-supported property.
 * @get_pm_enabled: Getter for the #UDisksDriveAta:pm-enabled property.
 * @get_pm_supported: Getter for the #UDisksDriveAta:pm-supported property.
 * @get_read_lookahead_enabled: Getter for the #UDisksDriveAta:read-lookahead-enabled property.
 * @get_read_lookahead_supported: Getter for the #UDisksDriveAta:read-lookahead-supported property.
 * @get_security_enhanced_erase_unit_minutes: Getter for the #UDisksDriveAta:security-enhanced-erase-unit-minutes property.
 * @get_security_erase_unit_minutes: Getter for the #UDisksDriveAta:security-erase-unit-minutes property.
 * @get_security_frozen: Getter for the #UDisksDriveAta:security-frozen property.
 * @get_smart_enabled: Getter for the #UDisksDriveAta:smart-enabled property.
 * @get_smart_failing: Getter for the #UDisksDriveAta:smart-failing property.
 * @get_smart_num_attributes_failed_in_the_past: Getter for the #UDisksDriveAta:smart-num-attributes-failed-in-the-past property.
 * @get_smart_num_attributes_failing: Getter for the #UDisksDriveAta:smart-num-attributes-failing property.
 * @get_smart_num_bad_sectors: Getter for the #UDisksDriveAta:smart-num-bad-sectors property.
 * @get_smart_power_on_seconds: Getter for the #UDisksDriveAta:smart-power-on-seconds property.
 * @get_smart_selftest_percent_remaining: Getter for the #UDisksDriveAta:smart-selftest-percent-remaining property.
 * @get_smart_selftest_status: Getter for the #UDisksDriveAta:smart-selftest-status property.
 * @get_smart_supported: Getter for the #UDisksDriveAta:smart-supported property.
 * @get_smart_temperature: Getter for the #UDisksDriveAta:smart-temperature property.
 * @get_smart_updated: Getter for the #UDisksDriveAta:smart-updated property.
 * @get_write_cache_enabled: Getter for the #UDisksDriveAta:write-cache-enabled property.
 * @get_write_cache_supported: Getter for the #UDisksDriveAta:write-cache-supported property.
 * @handle_smart_set_enabled: Handler for the #UDisksDriveAta::handle-smart-set-enabled signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive-Ata.top_of_page">org.freedesktop.UDisks2.Drive.Ata</link>.
 */

typedef UDisksDriveAtaIface UDisksDriveAtaInterface;
G_DEFINE_INTERFACE (UDisksDriveAta, udisks_drive_ata, G_TYPE_OBJECT)

static void
udisks_drive_ata_default_init (UDisksDriveAtaIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksDriveAta::handle-smart-update:
   * @object: A #UDisksDriveAta.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartUpdate">SmartUpdate()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_drive_ata_complete_smart_update() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-smart-update",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksDriveAtaIface, handle_smart_update),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_drive_ata_method_marshal_smart_update,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksDriveAta::handle-smart-get-attributes:
   * @object: A #UDisksDriveAta.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartGetAttributes">SmartGetAttributes()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_drive_ata_complete_smart_get_attributes() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-smart-get-attributes",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksDriveAtaIface, handle_smart_get_attributes),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_drive_ata_method_marshal_smart_get_attributes,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksDriveAta::handle-smart-selftest-start:
   * @object: A #UDisksDriveAta.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_type: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestStart">SmartSelftestStart()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_drive_ata_complete_smart_selftest_start() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-smart-selftest-start",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksDriveAtaIface, handle_smart_selftest_start),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_drive_ata_method_marshal_smart_selftest_start,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksDriveAta::handle-smart-selftest-abort:
   * @object: A #UDisksDriveAta.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestAbort">SmartSelftestAbort()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_drive_ata_complete_smart_selftest_abort() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-smart-selftest-abort",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksDriveAtaIface, handle_smart_selftest_abort),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_drive_ata_method_marshal_smart_selftest_abort,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksDriveAta::handle-smart-set-enabled:
   * @object: A #UDisksDriveAta.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_value: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartSetEnabled">SmartSetEnabled()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_drive_ata_complete_smart_set_enabled() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-smart-set-enabled",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksDriveAtaIface, handle_smart_set_enabled),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_drive_ata_method_marshal_smart_set_enabled,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_BOOLEAN, G_TYPE_VARIANT);

  /**
   * UDisksDriveAta::handle-pm-get-state:
   * @object: A #UDisksDriveAta.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.PmGetState">PmGetState()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_drive_ata_complete_pm_get_state() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-pm-get-state",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksDriveAtaIface, handle_pm_get_state),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_drive_ata_method_marshal_pm_get_state,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksDriveAta::handle-pm-standby:
   * @object: A #UDisksDriveAta.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.PmStandby">PmStandby()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_drive_ata_complete_pm_standby() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-pm-standby",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksDriveAtaIface, handle_pm_standby),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_drive_ata_method_marshal_pm_standby,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksDriveAta::handle-pm-wakeup:
   * @object: A #UDisksDriveAta.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.PmWakeup">PmWakeup()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_drive_ata_complete_pm_wakeup() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-pm-wakeup",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksDriveAtaIface, handle_pm_wakeup),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_drive_ata_method_marshal_pm_wakeup,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksDriveAta::handle-security-erase-unit:
   * @object: A #UDisksDriveAta.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SecurityEraseUnit">SecurityEraseUnit()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_drive_ata_complete_security_erase_unit() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-security-erase-unit",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksDriveAtaIface, handle_security_erase_unit),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_drive_ata_method_marshal_security_erase_unit,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksDriveAta:smart-supported:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartSupported">"SmartSupported"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("smart-supported", "SmartSupported", "SmartSupported", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:smart-enabled:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartEnabled">"SmartEnabled"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("smart-enabled", "SmartEnabled", "SmartEnabled", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:smart-updated:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartUpdated">"SmartUpdated"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("smart-updated", "SmartUpdated", "SmartUpdated", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:smart-failing:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartFailing">"SmartFailing"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("smart-failing", "SmartFailing", "SmartFailing", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:smart-power-on-seconds:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartPowerOnSeconds">"SmartPowerOnSeconds"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("smart-power-on-seconds", "SmartPowerOnSeconds", "SmartPowerOnSeconds", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:smart-temperature:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartTemperature">"SmartTemperature"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_double ("smart-temperature", "SmartTemperature", "SmartTemperature", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:smart-num-attributes-failing:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartNumAttributesFailing">"SmartNumAttributesFailing"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_int ("smart-num-attributes-failing", "SmartNumAttributesFailing", "SmartNumAttributesFailing", G_MININT32, G_MAXINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:smart-num-attributes-failed-in-the-past:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartNumAttributesFailedInThePast">"SmartNumAttributesFailedInThePast"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_int ("smart-num-attributes-failed-in-the-past", "SmartNumAttributesFailedInThePast", "SmartNumAttributesFailedInThePast", G_MININT32, G_MAXINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:smart-num-bad-sectors:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartNumBadSectors">"SmartNumBadSectors"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_int64 ("smart-num-bad-sectors", "SmartNumBadSectors", "SmartNumBadSectors", G_MININT64, G_MAXINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:smart-selftest-status:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestStatus">"SmartSelftestStatus"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("smart-selftest-status", "SmartSelftestStatus", "SmartSelftestStatus", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:smart-selftest-percent-remaining:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestPercentRemaining">"SmartSelftestPercentRemaining"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_int ("smart-selftest-percent-remaining", "SmartSelftestPercentRemaining", "SmartSelftestPercentRemaining", G_MININT32, G_MAXINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:pm-supported:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.PmSupported">"PmSupported"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("pm-supported", "PmSupported", "PmSupported", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:pm-enabled:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.PmEnabled">"PmEnabled"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("pm-enabled", "PmEnabled", "PmEnabled", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:apm-supported:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.ApmSupported">"ApmSupported"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("apm-supported", "ApmSupported", "ApmSupported", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:apm-enabled:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.ApmEnabled">"ApmEnabled"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("apm-enabled", "ApmEnabled", "ApmEnabled", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:aam-supported:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.AamSupported">"AamSupported"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("aam-supported", "AamSupported", "AamSupported", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:aam-enabled:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.AamEnabled">"AamEnabled"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("aam-enabled", "AamEnabled", "AamEnabled", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:aam-vendor-recommended-value:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.AamVendorRecommendedValue">"AamVendorRecommendedValue"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_int ("aam-vendor-recommended-value", "AamVendorRecommendedValue", "AamVendorRecommendedValue", G_MININT32, G_MAXINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:write-cache-supported:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.WriteCacheSupported">"WriteCacheSupported"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("write-cache-supported", "WriteCacheSupported", "WriteCacheSupported", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:write-cache-enabled:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.WriteCacheEnabled">"WriteCacheEnabled"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("write-cache-enabled", "WriteCacheEnabled", "WriteCacheEnabled", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:read-lookahead-supported:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.ReadLookaheadSupported">"ReadLookaheadSupported"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("read-lookahead-supported", "ReadLookaheadSupported", "ReadLookaheadSupported", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:read-lookahead-enabled:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.ReadLookaheadEnabled">"ReadLookaheadEnabled"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("read-lookahead-enabled", "ReadLookaheadEnabled", "ReadLookaheadEnabled", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:security-erase-unit-minutes:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SecurityEraseUnitMinutes">"SecurityEraseUnitMinutes"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_int ("security-erase-unit-minutes", "SecurityEraseUnitMinutes", "SecurityEraseUnitMinutes", G_MININT32, G_MAXINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:security-enhanced-erase-unit-minutes:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SecurityEnhancedEraseUnitMinutes">"SecurityEnhancedEraseUnitMinutes"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_int ("security-enhanced-erase-unit-minutes", "SecurityEnhancedEraseUnitMinutes", "SecurityEnhancedEraseUnitMinutes", G_MININT32, G_MAXINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksDriveAta:security-frozen:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SecurityFrozen">"SecurityFrozen"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("security-frozen", "SecurityFrozen", "SecurityFrozen", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_drive_ata_get_smart_supported: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartSupported">"SmartSupported"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_smart_supported (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_smart_supported (object);
}

/**
 * udisks_drive_ata_set_smart_supported: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartSupported">"SmartSupported"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_smart_supported (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "smart-supported", value, NULL);
}

/**
 * udisks_drive_ata_get_smart_enabled: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartEnabled">"SmartEnabled"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_smart_enabled (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_smart_enabled (object);
}

/**
 * udisks_drive_ata_set_smart_enabled: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartEnabled">"SmartEnabled"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_smart_enabled (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "smart-enabled", value, NULL);
}

/**
 * udisks_drive_ata_get_smart_updated: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartUpdated">"SmartUpdated"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_drive_ata_get_smart_updated (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), 0);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_smart_updated (object);
}

/**
 * udisks_drive_ata_set_smart_updated: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartUpdated">"SmartUpdated"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_smart_updated (UDisksDriveAta *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "smart-updated", value, NULL);
}

/**
 * udisks_drive_ata_get_smart_failing: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartFailing">"SmartFailing"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_smart_failing (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_smart_failing (object);
}

/**
 * udisks_drive_ata_set_smart_failing: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartFailing">"SmartFailing"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_smart_failing (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "smart-failing", value, NULL);
}

/**
 * udisks_drive_ata_get_smart_power_on_seconds: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartPowerOnSeconds">"SmartPowerOnSeconds"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_drive_ata_get_smart_power_on_seconds (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), 0);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_smart_power_on_seconds (object);
}

/**
 * udisks_drive_ata_set_smart_power_on_seconds: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartPowerOnSeconds">"SmartPowerOnSeconds"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_smart_power_on_seconds (UDisksDriveAta *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "smart-power-on-seconds", value, NULL);
}

/**
 * udisks_drive_ata_get_smart_temperature: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartTemperature">"SmartTemperature"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gdouble 
udisks_drive_ata_get_smart_temperature (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), 0.0);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_smart_temperature (object);
}

/**
 * udisks_drive_ata_set_smart_temperature: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartTemperature">"SmartTemperature"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_smart_temperature (UDisksDriveAta *object, gdouble value)
{
  g_object_set (G_OBJECT (object), "smart-temperature", value, NULL);
}

/**
 * udisks_drive_ata_get_smart_num_attributes_failing: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartNumAttributesFailing">"SmartNumAttributesFailing"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gint 
udisks_drive_ata_get_smart_num_attributes_failing (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), 0);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_smart_num_attributes_failing (object);
}

/**
 * udisks_drive_ata_set_smart_num_attributes_failing: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartNumAttributesFailing">"SmartNumAttributesFailing"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_smart_num_attributes_failing (UDisksDriveAta *object, gint value)
{
  g_object_set (G_OBJECT (object), "smart-num-attributes-failing", value, NULL);
}

/**
 * udisks_drive_ata_get_smart_num_attributes_failed_in_the_past: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartNumAttributesFailedInThePast">"SmartNumAttributesFailedInThePast"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gint 
udisks_drive_ata_get_smart_num_attributes_failed_in_the_past (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), 0);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_smart_num_attributes_failed_in_the_past (object);
}

/**
 * udisks_drive_ata_set_smart_num_attributes_failed_in_the_past: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartNumAttributesFailedInThePast">"SmartNumAttributesFailedInThePast"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_smart_num_attributes_failed_in_the_past (UDisksDriveAta *object, gint value)
{
  g_object_set (G_OBJECT (object), "smart-num-attributes-failed-in-the-past", value, NULL);
}

/**
 * udisks_drive_ata_get_smart_num_bad_sectors: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartNumBadSectors">"SmartNumBadSectors"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gint64 
udisks_drive_ata_get_smart_num_bad_sectors (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), 0);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_smart_num_bad_sectors (object);
}

/**
 * udisks_drive_ata_set_smart_num_bad_sectors: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartNumBadSectors">"SmartNumBadSectors"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_smart_num_bad_sectors (UDisksDriveAta *object, gint64 value)
{
  g_object_set (G_OBJECT (object), "smart-num-bad-sectors", value, NULL);
}

/**
 * udisks_drive_ata_get_smart_selftest_status: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestStatus">"SmartSelftestStatus"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_drive_ata_dup_smart_selftest_status() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_drive_ata_get_smart_selftest_status (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), NULL);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_smart_selftest_status (object);
}

/**
 * udisks_drive_ata_dup_smart_selftest_status: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestStatus">"SmartSelftestStatus"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_drive_ata_dup_smart_selftest_status (UDisksDriveAta *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "smart-selftest-status", &value, NULL);
  return value;
}

/**
 * udisks_drive_ata_set_smart_selftest_status: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestStatus">"SmartSelftestStatus"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_smart_selftest_status (UDisksDriveAta *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "smart-selftest-status", value, NULL);
}

/**
 * udisks_drive_ata_get_smart_selftest_percent_remaining: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestPercentRemaining">"SmartSelftestPercentRemaining"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gint 
udisks_drive_ata_get_smart_selftest_percent_remaining (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), 0);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_smart_selftest_percent_remaining (object);
}

/**
 * udisks_drive_ata_set_smart_selftest_percent_remaining: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestPercentRemaining">"SmartSelftestPercentRemaining"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_smart_selftest_percent_remaining (UDisksDriveAta *object, gint value)
{
  g_object_set (G_OBJECT (object), "smart-selftest-percent-remaining", value, NULL);
}

/**
 * udisks_drive_ata_get_pm_supported: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.PmSupported">"PmSupported"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_pm_supported (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_pm_supported (object);
}

/**
 * udisks_drive_ata_set_pm_supported: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.PmSupported">"PmSupported"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_pm_supported (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "pm-supported", value, NULL);
}

/**
 * udisks_drive_ata_get_pm_enabled: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.PmEnabled">"PmEnabled"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_pm_enabled (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_pm_enabled (object);
}

/**
 * udisks_drive_ata_set_pm_enabled: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.PmEnabled">"PmEnabled"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_pm_enabled (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "pm-enabled", value, NULL);
}

/**
 * udisks_drive_ata_get_apm_supported: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.ApmSupported">"ApmSupported"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_apm_supported (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_apm_supported (object);
}

/**
 * udisks_drive_ata_set_apm_supported: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.ApmSupported">"ApmSupported"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_apm_supported (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "apm-supported", value, NULL);
}

/**
 * udisks_drive_ata_get_apm_enabled: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.ApmEnabled">"ApmEnabled"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_apm_enabled (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_apm_enabled (object);
}

/**
 * udisks_drive_ata_set_apm_enabled: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.ApmEnabled">"ApmEnabled"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_apm_enabled (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "apm-enabled", value, NULL);
}

/**
 * udisks_drive_ata_get_aam_supported: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.AamSupported">"AamSupported"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_aam_supported (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_aam_supported (object);
}

/**
 * udisks_drive_ata_set_aam_supported: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.AamSupported">"AamSupported"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_aam_supported (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "aam-supported", value, NULL);
}

/**
 * udisks_drive_ata_get_aam_enabled: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.AamEnabled">"AamEnabled"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_aam_enabled (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_aam_enabled (object);
}

/**
 * udisks_drive_ata_set_aam_enabled: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.AamEnabled">"AamEnabled"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_aam_enabled (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "aam-enabled", value, NULL);
}

/**
 * udisks_drive_ata_get_aam_vendor_recommended_value: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.AamVendorRecommendedValue">"AamVendorRecommendedValue"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gint 
udisks_drive_ata_get_aam_vendor_recommended_value (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), 0);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_aam_vendor_recommended_value (object);
}

/**
 * udisks_drive_ata_set_aam_vendor_recommended_value: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.AamVendorRecommendedValue">"AamVendorRecommendedValue"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_aam_vendor_recommended_value (UDisksDriveAta *object, gint value)
{
  g_object_set (G_OBJECT (object), "aam-vendor-recommended-value", value, NULL);
}

/**
 * udisks_drive_ata_get_write_cache_supported: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.WriteCacheSupported">"WriteCacheSupported"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_write_cache_supported (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_write_cache_supported (object);
}

/**
 * udisks_drive_ata_set_write_cache_supported: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.WriteCacheSupported">"WriteCacheSupported"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_write_cache_supported (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "write-cache-supported", value, NULL);
}

/**
 * udisks_drive_ata_get_write_cache_enabled: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.WriteCacheEnabled">"WriteCacheEnabled"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_write_cache_enabled (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_write_cache_enabled (object);
}

/**
 * udisks_drive_ata_set_write_cache_enabled: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.WriteCacheEnabled">"WriteCacheEnabled"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_write_cache_enabled (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "write-cache-enabled", value, NULL);
}

/**
 * udisks_drive_ata_get_read_lookahead_supported: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.ReadLookaheadSupported">"ReadLookaheadSupported"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_read_lookahead_supported (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_read_lookahead_supported (object);
}

/**
 * udisks_drive_ata_set_read_lookahead_supported: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.ReadLookaheadSupported">"ReadLookaheadSupported"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_read_lookahead_supported (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "read-lookahead-supported", value, NULL);
}

/**
 * udisks_drive_ata_get_read_lookahead_enabled: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.ReadLookaheadEnabled">"ReadLookaheadEnabled"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_read_lookahead_enabled (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_read_lookahead_enabled (object);
}

/**
 * udisks_drive_ata_set_read_lookahead_enabled: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.ReadLookaheadEnabled">"ReadLookaheadEnabled"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_read_lookahead_enabled (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "read-lookahead-enabled", value, NULL);
}

/**
 * udisks_drive_ata_get_security_erase_unit_minutes: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SecurityEraseUnitMinutes">"SecurityEraseUnitMinutes"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gint 
udisks_drive_ata_get_security_erase_unit_minutes (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), 0);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_security_erase_unit_minutes (object);
}

/**
 * udisks_drive_ata_set_security_erase_unit_minutes: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SecurityEraseUnitMinutes">"SecurityEraseUnitMinutes"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_security_erase_unit_minutes (UDisksDriveAta *object, gint value)
{
  g_object_set (G_OBJECT (object), "security-erase-unit-minutes", value, NULL);
}

/**
 * udisks_drive_ata_get_security_enhanced_erase_unit_minutes: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SecurityEnhancedEraseUnitMinutes">"SecurityEnhancedEraseUnitMinutes"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gint 
udisks_drive_ata_get_security_enhanced_erase_unit_minutes (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), 0);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_security_enhanced_erase_unit_minutes (object);
}

/**
 * udisks_drive_ata_set_security_enhanced_erase_unit_minutes: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SecurityEnhancedEraseUnitMinutes">"SecurityEnhancedEraseUnitMinutes"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_security_enhanced_erase_unit_minutes (UDisksDriveAta *object, gint value)
{
  g_object_set (G_OBJECT (object), "security-enhanced-erase-unit-minutes", value, NULL);
}

/**
 * udisks_drive_ata_get_security_frozen: (skip)
 * @object: A #UDisksDriveAta.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SecurityFrozen">"SecurityFrozen"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_drive_ata_get_security_frozen (UDisksDriveAta *object)
{
  g_return_val_if_fail (UDISKS_IS_DRIVE_ATA (object), FALSE);

  return UDISKS_DRIVE_ATA_GET_IFACE (object)->get_security_frozen (object);
}

/**
 * udisks_drive_ata_set_security_frozen: (skip)
 * @object: A #UDisksDriveAta.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Drive-Ata.SecurityFrozen">"SecurityFrozen"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_drive_ata_set_security_frozen (UDisksDriveAta *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "security-frozen", value, NULL);
}

/**
 * udisks_drive_ata_call_smart_update:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartUpdate">SmartUpdate()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_ata_call_smart_update_finish() to get the result of the operation.
 *
 * See udisks_drive_ata_call_smart_update_sync() for the synchronous, blocking version of this method.
 */
void
udisks_drive_ata_call_smart_update (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SmartUpdate",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_drive_ata_call_smart_update_finish:
 * @proxy: A #UDisksDriveAtaProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_ata_call_smart_update().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_drive_ata_call_smart_update().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_smart_update_finish (
    UDisksDriveAta *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_smart_update_sync:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartUpdate">SmartUpdate()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_ata_call_smart_update() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_smart_update_sync (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SmartUpdate",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_smart_get_attributes:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartGetAttributes">SmartGetAttributes()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_ata_call_smart_get_attributes_finish() to get the result of the operation.
 *
 * See udisks_drive_ata_call_smart_get_attributes_sync() for the synchronous, blocking version of this method.
 */
void
udisks_drive_ata_call_smart_get_attributes (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SmartGetAttributes",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_drive_ata_call_smart_get_attributes_finish:
 * @proxy: A #UDisksDriveAtaProxy.
 * @out_attributes: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_ata_call_smart_get_attributes().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_drive_ata_call_smart_get_attributes().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_smart_get_attributes_finish (
    UDisksDriveAta *proxy,
    GVariant ** out_attributes,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@a(ysqiiixia{sv}))",
                 out_attributes);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_smart_get_attributes_sync:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @out_attributes: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartGetAttributes">SmartGetAttributes()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_ata_call_smart_get_attributes() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_smart_get_attributes_sync (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    GVariant ** out_attributes,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SmartGetAttributes",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@a(ysqiiixia{sv}))",
                 out_attributes);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_smart_selftest_start:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestStart">SmartSelftestStart()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_ata_call_smart_selftest_start_finish() to get the result of the operation.
 *
 * See udisks_drive_ata_call_smart_selftest_start_sync() for the synchronous, blocking version of this method.
 */
void
udisks_drive_ata_call_smart_selftest_start (
    UDisksDriveAta *proxy,
    const gchar *arg_type,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SmartSelftestStart",
    g_variant_new ("(s@a{sv})",
                   arg_type,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_drive_ata_call_smart_selftest_start_finish:
 * @proxy: A #UDisksDriveAtaProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_ata_call_smart_selftest_start().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_drive_ata_call_smart_selftest_start().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_smart_selftest_start_finish (
    UDisksDriveAta *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_smart_selftest_start_sync:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestStart">SmartSelftestStart()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_ata_call_smart_selftest_start() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_smart_selftest_start_sync (
    UDisksDriveAta *proxy,
    const gchar *arg_type,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SmartSelftestStart",
    g_variant_new ("(s@a{sv})",
                   arg_type,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_smart_selftest_abort:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestAbort">SmartSelftestAbort()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_ata_call_smart_selftest_abort_finish() to get the result of the operation.
 *
 * See udisks_drive_ata_call_smart_selftest_abort_sync() for the synchronous, blocking version of this method.
 */
void
udisks_drive_ata_call_smart_selftest_abort (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SmartSelftestAbort",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_drive_ata_call_smart_selftest_abort_finish:
 * @proxy: A #UDisksDriveAtaProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_ata_call_smart_selftest_abort().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_drive_ata_call_smart_selftest_abort().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_smart_selftest_abort_finish (
    UDisksDriveAta *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_smart_selftest_abort_sync:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestAbort">SmartSelftestAbort()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_ata_call_smart_selftest_abort() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_smart_selftest_abort_sync (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SmartSelftestAbort",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_smart_set_enabled:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_value: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartSetEnabled">SmartSetEnabled()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_ata_call_smart_set_enabled_finish() to get the result of the operation.
 *
 * See udisks_drive_ata_call_smart_set_enabled_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_drive_ata_call_smart_set_enabled (
    UDisksDriveAta *proxy,
    gboolean arg_value,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SmartSetEnabled",
    g_variant_new ("(b@a{sv})",
                   arg_value,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_drive_ata_call_smart_set_enabled_finish:
 * @proxy: A #UDisksDriveAtaProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_ata_call_smart_set_enabled().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_drive_ata_call_smart_set_enabled().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_drive_ata_call_smart_set_enabled_finish (
    UDisksDriveAta *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_smart_set_enabled_sync:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_value: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartSetEnabled">SmartSetEnabled()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_ata_call_smart_set_enabled() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_drive_ata_call_smart_set_enabled_sync (
    UDisksDriveAta *proxy,
    gboolean arg_value,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SmartSetEnabled",
    g_variant_new ("(b@a{sv})",
                   arg_value,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_pm_get_state:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.PmGetState">PmGetState()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_ata_call_pm_get_state_finish() to get the result of the operation.
 *
 * See udisks_drive_ata_call_pm_get_state_sync() for the synchronous, blocking version of this method.
 */
void
udisks_drive_ata_call_pm_get_state (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "PmGetState",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_drive_ata_call_pm_get_state_finish:
 * @proxy: A #UDisksDriveAtaProxy.
 * @out_state: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_ata_call_pm_get_state().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_drive_ata_call_pm_get_state().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_pm_get_state_finish (
    UDisksDriveAta *proxy,
    guchar* out_state,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(y)",
                 out_state);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_pm_get_state_sync:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @out_state: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.PmGetState">PmGetState()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_ata_call_pm_get_state() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_pm_get_state_sync (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    guchar* out_state,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "PmGetState",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(y)",
                 out_state);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_pm_standby:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.PmStandby">PmStandby()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_ata_call_pm_standby_finish() to get the result of the operation.
 *
 * See udisks_drive_ata_call_pm_standby_sync() for the synchronous, blocking version of this method.
 */
void
udisks_drive_ata_call_pm_standby (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "PmStandby",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_drive_ata_call_pm_standby_finish:
 * @proxy: A #UDisksDriveAtaProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_ata_call_pm_standby().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_drive_ata_call_pm_standby().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_pm_standby_finish (
    UDisksDriveAta *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_pm_standby_sync:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.PmStandby">PmStandby()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_ata_call_pm_standby() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_pm_standby_sync (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "PmStandby",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_pm_wakeup:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.PmWakeup">PmWakeup()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_ata_call_pm_wakeup_finish() to get the result of the operation.
 *
 * See udisks_drive_ata_call_pm_wakeup_sync() for the synchronous, blocking version of this method.
 */
void
udisks_drive_ata_call_pm_wakeup (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "PmWakeup",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_drive_ata_call_pm_wakeup_finish:
 * @proxy: A #UDisksDriveAtaProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_ata_call_pm_wakeup().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_drive_ata_call_pm_wakeup().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_pm_wakeup_finish (
    UDisksDriveAta *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_pm_wakeup_sync:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.PmWakeup">PmWakeup()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_ata_call_pm_wakeup() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_pm_wakeup_sync (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "PmWakeup",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_security_erase_unit:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SecurityEraseUnit">SecurityEraseUnit()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_ata_call_security_erase_unit_finish() to get the result of the operation.
 *
 * See udisks_drive_ata_call_security_erase_unit_sync() for the synchronous, blocking version of this method.
 */
void
udisks_drive_ata_call_security_erase_unit (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SecurityEraseUnit",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_drive_ata_call_security_erase_unit_finish:
 * @proxy: A #UDisksDriveAtaProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_ata_call_security_erase_unit().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_drive_ata_call_security_erase_unit().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_security_erase_unit_finish (
    UDisksDriveAta *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_call_security_erase_unit_sync:
 * @proxy: A #UDisksDriveAtaProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SecurityEraseUnit">SecurityEraseUnit()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_ata_call_security_erase_unit() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_drive_ata_call_security_erase_unit_sync (
    UDisksDriveAta *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SecurityEraseUnit",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_drive_ata_complete_smart_update:
 * @object: A #UDisksDriveAta.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartUpdate">SmartUpdate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_drive_ata_complete_smart_update (
    UDisksDriveAta *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_drive_ata_complete_smart_get_attributes:
 * @object: A #UDisksDriveAta.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @attributes: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartGetAttributes">SmartGetAttributes()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_drive_ata_complete_smart_get_attributes (
    UDisksDriveAta *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GVariant *attributes)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(@a(ysqiiixia{sv}))",
                   attributes));
}

/**
 * udisks_drive_ata_complete_smart_selftest_start:
 * @object: A #UDisksDriveAta.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestStart">SmartSelftestStart()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_drive_ata_complete_smart_selftest_start (
    UDisksDriveAta *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_drive_ata_complete_smart_selftest_abort:
 * @object: A #UDisksDriveAta.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartSelftestAbort">SmartSelftestAbort()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_drive_ata_complete_smart_selftest_abort (
    UDisksDriveAta *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_drive_ata_complete_smart_set_enabled:
 * @object: A #UDisksDriveAta.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SmartSetEnabled">SmartSetEnabled()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_drive_ata_complete_smart_set_enabled (
    UDisksDriveAta *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_drive_ata_complete_pm_get_state:
 * @object: A #UDisksDriveAta.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @state: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.PmGetState">PmGetState()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_drive_ata_complete_pm_get_state (
    UDisksDriveAta *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    guchar state)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(y)",
                   state));
}

/**
 * udisks_drive_ata_complete_pm_standby:
 * @object: A #UDisksDriveAta.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.PmStandby">PmStandby()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_drive_ata_complete_pm_standby (
    UDisksDriveAta *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_drive_ata_complete_pm_wakeup:
 * @object: A #UDisksDriveAta.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.PmWakeup">PmWakeup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_drive_ata_complete_pm_wakeup (
    UDisksDriveAta *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_drive_ata_complete_security_erase_unit:
 * @object: A #UDisksDriveAta.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Drive-Ata.SecurityEraseUnit">SecurityEraseUnit()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_drive_ata_complete_security_erase_unit (
    UDisksDriveAta *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksDriveAtaProxy:
 *
 * The #UDisksDriveAtaProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksDriveAtaProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksDriveAtaProxy.
 */

struct _UDisksDriveAtaProxyPrivate
{
  GData *qdata;
};

static void udisks_drive_ata_proxy_iface_init (UDisksDriveAtaIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksDriveAtaProxy, udisks_drive_ata_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksDriveAtaProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_DRIVE_ATA, udisks_drive_ata_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksDriveAtaProxy, udisks_drive_ata_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_DRIVE_ATA, udisks_drive_ata_proxy_iface_init))

#endif
static void
udisks_drive_ata_proxy_finalize (GObject *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_drive_ata_proxy_parent_class)->finalize (object);
}

static void
udisks_drive_ata_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 25);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_drive_ata_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_drive_ata_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.Drive.Ata: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_drive_ata_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 25);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_drive_ata_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.Drive.Ata", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_drive_ata_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_drive_ata_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_drive_ata_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_DRIVE_ATA);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_DRIVE_ATA);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_drive_ata_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_drive_ata_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_drive_ata_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static gboolean 
udisks_drive_ata_proxy_get_smart_supported (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartSupported");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_ata_proxy_get_smart_enabled (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartEnabled");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_drive_ata_proxy_get_smart_updated (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartUpdated");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_ata_proxy_get_smart_failing (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartFailing");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_drive_ata_proxy_get_smart_power_on_seconds (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartPowerOnSeconds");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gdouble 
udisks_drive_ata_proxy_get_smart_temperature (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gdouble value = 0.0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartTemperature");
  if (variant != NULL)
    {
      value = g_variant_get_double (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gint 
udisks_drive_ata_proxy_get_smart_num_attributes_failing (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartNumAttributesFailing");
  if (variant != NULL)
    {
      value = g_variant_get_int32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gint 
udisks_drive_ata_proxy_get_smart_num_attributes_failed_in_the_past (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartNumAttributesFailedInThePast");
  if (variant != NULL)
    {
      value = g_variant_get_int32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gint64 
udisks_drive_ata_proxy_get_smart_num_bad_sectors (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartNumBadSectors");
  if (variant != NULL)
    {
      value = g_variant_get_int64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_drive_ata_proxy_get_smart_selftest_status (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartSelftestStatus");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static gint 
udisks_drive_ata_proxy_get_smart_selftest_percent_remaining (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartSelftestPercentRemaining");
  if (variant != NULL)
    {
      value = g_variant_get_int32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_ata_proxy_get_pm_supported (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "PmSupported");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_ata_proxy_get_pm_enabled (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "PmEnabled");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_ata_proxy_get_apm_supported (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ApmSupported");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_ata_proxy_get_apm_enabled (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ApmEnabled");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_ata_proxy_get_aam_supported (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "AamSupported");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_ata_proxy_get_aam_enabled (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "AamEnabled");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gint 
udisks_drive_ata_proxy_get_aam_vendor_recommended_value (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "AamVendorRecommendedValue");
  if (variant != NULL)
    {
      value = g_variant_get_int32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_ata_proxy_get_write_cache_supported (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "WriteCacheSupported");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_ata_proxy_get_write_cache_enabled (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "WriteCacheEnabled");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_ata_proxy_get_read_lookahead_supported (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ReadLookaheadSupported");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_ata_proxy_get_read_lookahead_enabled (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ReadLookaheadEnabled");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gint 
udisks_drive_ata_proxy_get_security_erase_unit_minutes (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SecurityEraseUnitMinutes");
  if (variant != NULL)
    {
      value = g_variant_get_int32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gint 
udisks_drive_ata_proxy_get_security_enhanced_erase_unit_minutes (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SecurityEnhancedEraseUnitMinutes");
  if (variant != NULL)
    {
      value = g_variant_get_int32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_drive_ata_proxy_get_security_frozen (UDisksDriveAta *object)
{
  UDisksDriveAtaProxy *proxy = UDISKS_DRIVE_ATA_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SecurityFrozen");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_drive_ata_proxy_init (UDisksDriveAtaProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_drive_ata_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_DRIVE_ATA_PROXY, UDisksDriveAtaProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_drive_ata_interface_info ());
}

static void
udisks_drive_ata_proxy_class_init (UDisksDriveAtaProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_drive_ata_proxy_finalize;
  gobject_class->get_property = udisks_drive_ata_proxy_get_property;
  gobject_class->set_property = udisks_drive_ata_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_drive_ata_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_drive_ata_proxy_g_properties_changed;

  udisks_drive_ata_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksDriveAtaProxyPrivate));
#endif
}

static void
udisks_drive_ata_proxy_iface_init (UDisksDriveAtaIface *iface)
{
  iface->get_smart_supported = udisks_drive_ata_proxy_get_smart_supported;
  iface->get_smart_enabled = udisks_drive_ata_proxy_get_smart_enabled;
  iface->get_smart_updated = udisks_drive_ata_proxy_get_smart_updated;
  iface->get_smart_failing = udisks_drive_ata_proxy_get_smart_failing;
  iface->get_smart_power_on_seconds = udisks_drive_ata_proxy_get_smart_power_on_seconds;
  iface->get_smart_temperature = udisks_drive_ata_proxy_get_smart_temperature;
  iface->get_smart_num_attributes_failing = udisks_drive_ata_proxy_get_smart_num_attributes_failing;
  iface->get_smart_num_attributes_failed_in_the_past = udisks_drive_ata_proxy_get_smart_num_attributes_failed_in_the_past;
  iface->get_smart_num_bad_sectors = udisks_drive_ata_proxy_get_smart_num_bad_sectors;
  iface->get_smart_selftest_status = udisks_drive_ata_proxy_get_smart_selftest_status;
  iface->get_smart_selftest_percent_remaining = udisks_drive_ata_proxy_get_smart_selftest_percent_remaining;
  iface->get_pm_supported = udisks_drive_ata_proxy_get_pm_supported;
  iface->get_pm_enabled = udisks_drive_ata_proxy_get_pm_enabled;
  iface->get_apm_supported = udisks_drive_ata_proxy_get_apm_supported;
  iface->get_apm_enabled = udisks_drive_ata_proxy_get_apm_enabled;
  iface->get_aam_supported = udisks_drive_ata_proxy_get_aam_supported;
  iface->get_aam_enabled = udisks_drive_ata_proxy_get_aam_enabled;
  iface->get_aam_vendor_recommended_value = udisks_drive_ata_proxy_get_aam_vendor_recommended_value;
  iface->get_write_cache_supported = udisks_drive_ata_proxy_get_write_cache_supported;
  iface->get_write_cache_enabled = udisks_drive_ata_proxy_get_write_cache_enabled;
  iface->get_read_lookahead_supported = udisks_drive_ata_proxy_get_read_lookahead_supported;
  iface->get_read_lookahead_enabled = udisks_drive_ata_proxy_get_read_lookahead_enabled;
  iface->get_security_erase_unit_minutes = udisks_drive_ata_proxy_get_security_erase_unit_minutes;
  iface->get_security_enhanced_erase_unit_minutes = udisks_drive_ata_proxy_get_security_enhanced_erase_unit_minutes;
  iface->get_security_frozen = udisks_drive_ata_proxy_get_security_frozen;
}

/**
 * udisks_drive_ata_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive-Ata.top_of_page">org.freedesktop.UDisks2.Drive.Ata</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_ata_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_drive_ata_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_drive_ata_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_DRIVE_ATA_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Drive.Ata", NULL);
}

/**
 * udisks_drive_ata_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_ata_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_drive_ata_proxy_new().
 *
 * Returns: (transfer full) (type UDisksDriveAtaProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksDriveAta *
udisks_drive_ata_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_DRIVE_ATA (ret);
  else
    return NULL;
}

/**
 * udisks_drive_ata_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive-Ata.top_of_page">org.freedesktop.UDisks2.Drive.Ata</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_ata_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksDriveAtaProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksDriveAta *
udisks_drive_ata_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_DRIVE_ATA_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Drive.Ata", NULL);
  if (ret != NULL)
    return UDISKS_DRIVE_ATA (ret);
  else
    return NULL;
}


/**
 * udisks_drive_ata_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_drive_ata_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_drive_ata_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_drive_ata_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_drive_ata_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_DRIVE_ATA_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Drive.Ata", NULL);
}

/**
 * udisks_drive_ata_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_drive_ata_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_drive_ata_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksDriveAtaProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksDriveAta *
udisks_drive_ata_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_DRIVE_ATA (ret);
  else
    return NULL;
}

/**
 * udisks_drive_ata_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_drive_ata_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_drive_ata_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksDriveAtaProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksDriveAta *
udisks_drive_ata_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_DRIVE_ATA_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Drive.Ata", NULL);
  if (ret != NULL)
    return UDISKS_DRIVE_ATA (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksDriveAtaSkeleton:
 *
 * The #UDisksDriveAtaSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksDriveAtaSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksDriveAtaSkeleton.
 */

struct _UDisksDriveAtaSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_drive_ata_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_DRIVE_ATA);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_DRIVE_ATA);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_drive_ata_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_drive_ata_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_drive_ata_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_drive_ata_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_drive_ata_skeleton_vtable =
{
  _udisks_drive_ata_skeleton_handle_method_call,
  _udisks_drive_ata_skeleton_handle_get_property,
  _udisks_drive_ata_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_drive_ata_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_drive_ata_interface_info ();
}

static GDBusInterfaceVTable *
udisks_drive_ata_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_drive_ata_skeleton_vtable;
}

static GVariant *
udisks_drive_ata_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_drive_ata_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_drive_ata_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_drive_ata_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_drive_ata_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Drive.Ata", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_drive_ata_emit_changed (gpointer user_data);

static void
udisks_drive_ata_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_drive_ata_emit_changed (skeleton);
}

static void udisks_drive_ata_skeleton_iface_init (UDisksDriveAtaIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksDriveAtaSkeleton, udisks_drive_ata_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksDriveAtaSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_DRIVE_ATA, udisks_drive_ata_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksDriveAtaSkeleton, udisks_drive_ata_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_DRIVE_ATA, udisks_drive_ata_skeleton_iface_init))

#endif
static void
udisks_drive_ata_skeleton_finalize (GObject *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  guint n;
  for (n = 0; n < 25; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_drive_ata_skeleton_parent_class)->finalize (object);
}

static void
udisks_drive_ata_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 25);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_drive_ata_emit_changed (gpointer user_data)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.Drive.Ata",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_drive_ata_schedule_emit_changed (UDisksDriveAtaSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_drive_ata_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_drive_ata_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_drive_ata_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_drive_ata_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 25);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_drive_ata_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_drive_ata_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_drive_ata_skeleton_init (UDisksDriveAtaSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_drive_ata_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_DRIVE_ATA_SKELETON, UDisksDriveAtaSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 25);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[4], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[5], G_TYPE_DOUBLE);
  g_value_init (&skeleton->priv->properties[6], G_TYPE_INT);
  g_value_init (&skeleton->priv->properties[7], G_TYPE_INT);
  g_value_init (&skeleton->priv->properties[8], G_TYPE_INT64);
  g_value_init (&skeleton->priv->properties[9], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[10], G_TYPE_INT);
  g_value_init (&skeleton->priv->properties[11], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[12], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[13], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[14], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[15], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[16], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[17], G_TYPE_INT);
  g_value_init (&skeleton->priv->properties[18], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[19], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[20], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[21], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[22], G_TYPE_INT);
  g_value_init (&skeleton->priv->properties[23], G_TYPE_INT);
  g_value_init (&skeleton->priv->properties[24], G_TYPE_BOOLEAN);
}

static gboolean 
udisks_drive_ata_skeleton_get_smart_supported (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_ata_skeleton_get_smart_enabled (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_drive_ata_skeleton_get_smart_updated (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_ata_skeleton_get_smart_failing (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_drive_ata_skeleton_get_smart_power_on_seconds (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[4]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gdouble 
udisks_drive_ata_skeleton_get_smart_temperature (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gdouble value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_double (&(skeleton->priv->properties[5]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gint 
udisks_drive_ata_skeleton_get_smart_num_attributes_failing (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_int (&(skeleton->priv->properties[6]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gint 
udisks_drive_ata_skeleton_get_smart_num_attributes_failed_in_the_past (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_int (&(skeleton->priv->properties[7]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gint64 
udisks_drive_ata_skeleton_get_smart_num_bad_sectors (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_int64 (&(skeleton->priv->properties[8]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_drive_ata_skeleton_get_smart_selftest_status (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[9]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gint 
udisks_drive_ata_skeleton_get_smart_selftest_percent_remaining (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_int (&(skeleton->priv->properties[10]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_ata_skeleton_get_pm_supported (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[11]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_ata_skeleton_get_pm_enabled (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[12]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_ata_skeleton_get_apm_supported (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[13]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_ata_skeleton_get_apm_enabled (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[14]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_ata_skeleton_get_aam_supported (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[15]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_ata_skeleton_get_aam_enabled (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[16]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gint 
udisks_drive_ata_skeleton_get_aam_vendor_recommended_value (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_int (&(skeleton->priv->properties[17]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_ata_skeleton_get_write_cache_supported (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[18]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_ata_skeleton_get_write_cache_enabled (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[19]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_ata_skeleton_get_read_lookahead_supported (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[20]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_ata_skeleton_get_read_lookahead_enabled (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[21]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gint 
udisks_drive_ata_skeleton_get_security_erase_unit_minutes (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_int (&(skeleton->priv->properties[22]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gint 
udisks_drive_ata_skeleton_get_security_enhanced_erase_unit_minutes (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_int (&(skeleton->priv->properties[23]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_drive_ata_skeleton_get_security_frozen (UDisksDriveAta *object)
{
  UDisksDriveAtaSkeleton *skeleton = UDISKS_DRIVE_ATA_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[24]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_drive_ata_skeleton_class_init (UDisksDriveAtaSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_drive_ata_skeleton_finalize;
  gobject_class->get_property = udisks_drive_ata_skeleton_get_property;
  gobject_class->set_property = udisks_drive_ata_skeleton_set_property;
  gobject_class->notify       = udisks_drive_ata_skeleton_notify;


  udisks_drive_ata_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_drive_ata_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_drive_ata_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_drive_ata_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_drive_ata_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksDriveAtaSkeletonPrivate));
#endif
}

static void
udisks_drive_ata_skeleton_iface_init (UDisksDriveAtaIface *iface)
{
  iface->get_smart_supported = udisks_drive_ata_skeleton_get_smart_supported;
  iface->get_smart_enabled = udisks_drive_ata_skeleton_get_smart_enabled;
  iface->get_smart_updated = udisks_drive_ata_skeleton_get_smart_updated;
  iface->get_smart_failing = udisks_drive_ata_skeleton_get_smart_failing;
  iface->get_smart_power_on_seconds = udisks_drive_ata_skeleton_get_smart_power_on_seconds;
  iface->get_smart_temperature = udisks_drive_ata_skeleton_get_smart_temperature;
  iface->get_smart_num_attributes_failing = udisks_drive_ata_skeleton_get_smart_num_attributes_failing;
  iface->get_smart_num_attributes_failed_in_the_past = udisks_drive_ata_skeleton_get_smart_num_attributes_failed_in_the_past;
  iface->get_smart_num_bad_sectors = udisks_drive_ata_skeleton_get_smart_num_bad_sectors;
  iface->get_smart_selftest_status = udisks_drive_ata_skeleton_get_smart_selftest_status;
  iface->get_smart_selftest_percent_remaining = udisks_drive_ata_skeleton_get_smart_selftest_percent_remaining;
  iface->get_pm_supported = udisks_drive_ata_skeleton_get_pm_supported;
  iface->get_pm_enabled = udisks_drive_ata_skeleton_get_pm_enabled;
  iface->get_apm_supported = udisks_drive_ata_skeleton_get_apm_supported;
  iface->get_apm_enabled = udisks_drive_ata_skeleton_get_apm_enabled;
  iface->get_aam_supported = udisks_drive_ata_skeleton_get_aam_supported;
  iface->get_aam_enabled = udisks_drive_ata_skeleton_get_aam_enabled;
  iface->get_aam_vendor_recommended_value = udisks_drive_ata_skeleton_get_aam_vendor_recommended_value;
  iface->get_write_cache_supported = udisks_drive_ata_skeleton_get_write_cache_supported;
  iface->get_write_cache_enabled = udisks_drive_ata_skeleton_get_write_cache_enabled;
  iface->get_read_lookahead_supported = udisks_drive_ata_skeleton_get_read_lookahead_supported;
  iface->get_read_lookahead_enabled = udisks_drive_ata_skeleton_get_read_lookahead_enabled;
  iface->get_security_erase_unit_minutes = udisks_drive_ata_skeleton_get_security_erase_unit_minutes;
  iface->get_security_enhanced_erase_unit_minutes = udisks_drive_ata_skeleton_get_security_enhanced_erase_unit_minutes;
  iface->get_security_frozen = udisks_drive_ata_skeleton_get_security_frozen;
}

/**
 * udisks_drive_ata_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive-Ata.top_of_page">org.freedesktop.UDisks2.Drive.Ata</link>.
 *
 * Returns: (transfer full) (type UDisksDriveAtaSkeleton): The skeleton object.
 */
UDisksDriveAta *
udisks_drive_ata_skeleton_new (void)
{
  return UDISKS_DRIVE_ATA (g_object_new (UDISKS_TYPE_DRIVE_ATA_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.NVMe.Controller
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksNVMeController
 * @title: UDisksNVMeController
 * @short_description: Generated C code for the org.freedesktop.UDisks2.NVMe.Controller D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Controller.top_of_page">org.freedesktop.UDisks2.NVMe.Controller</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.NVMe.Controller ---- */

static const _ExtendedGDBusArgInfo _udisks_nvme_controller_method_info_smart_update_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_nvme_controller_method_info_smart_update_IN_ARG_pointers[] =
{
  &_udisks_nvme_controller_method_info_smart_update_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_nvme_controller_method_info_smart_update =
{
  {
    -1,
    (gchar *) "SmartUpdate",
    (GDBusArgInfo **) &_udisks_nvme_controller_method_info_smart_update_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-smart-update",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_nvme_controller_method_info_smart_get_attributes_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_nvme_controller_method_info_smart_get_attributes_IN_ARG_pointers[] =
{
  &_udisks_nvme_controller_method_info_smart_get_attributes_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_nvme_controller_method_info_smart_get_attributes_OUT_ARG_attributes =
{
  {
    -1,
    (gchar *) "attributes",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_nvme_controller_method_info_smart_get_attributes_OUT_ARG_pointers[] =
{
  &_udisks_nvme_controller_method_info_smart_get_attributes_OUT_ARG_attributes.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_nvme_controller_method_info_smart_get_attributes =
{
  {
    -1,
    (gchar *) "SmartGetAttributes",
    (GDBusArgInfo **) &_udisks_nvme_controller_method_info_smart_get_attributes_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_nvme_controller_method_info_smart_get_attributes_OUT_ARG_pointers,
    NULL
  },
  "handle-smart-get-attributes",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_nvme_controller_method_info_smart_selftest_start_IN_ARG_type =
{
  {
    -1,
    (gchar *) "type",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_nvme_controller_method_info_smart_selftest_start_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_nvme_controller_method_info_smart_selftest_start_IN_ARG_pointers[] =
{
  &_udisks_nvme_controller_method_info_smart_selftest_start_IN_ARG_type.parent_struct,
  &_udisks_nvme_controller_method_info_smart_selftest_start_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_nvme_controller_method_info_smart_selftest_start =
{
  {
    -1,
    (gchar *) "SmartSelftestStart",
    (GDBusArgInfo **) &_udisks_nvme_controller_method_info_smart_selftest_start_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-smart-selftest-start",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_nvme_controller_method_info_smart_selftest_abort_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_nvme_controller_method_info_smart_selftest_abort_IN_ARG_pointers[] =
{
  &_udisks_nvme_controller_method_info_smart_selftest_abort_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_nvme_controller_method_info_smart_selftest_abort =
{
  {
    -1,
    (gchar *) "SmartSelftestAbort",
    (GDBusArgInfo **) &_udisks_nvme_controller_method_info_smart_selftest_abort_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-smart-selftest-abort",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_nvme_controller_method_info_sanitize_start_IN_ARG_action =
{
  {
    -1,
    (gchar *) "action",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_nvme_controller_method_info_sanitize_start_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_nvme_controller_method_info_sanitize_start_IN_ARG_pointers[] =
{
  &_udisks_nvme_controller_method_info_sanitize_start_IN_ARG_action.parent_struct,
  &_udisks_nvme_controller_method_info_sanitize_start_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_nvme_controller_method_info_sanitize_start =
{
  {
    -1,
    (gchar *) "SanitizeStart",
    (GDBusArgInfo **) &_udisks_nvme_controller_method_info_sanitize_start_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-sanitize-start",
  FALSE
};

static const GDBusMethodInfo * const _udisks_nvme_controller_method_info_pointers[] =
{
  &_udisks_nvme_controller_method_info_smart_update.parent_struct,
  &_udisks_nvme_controller_method_info_smart_get_attributes.parent_struct,
  &_udisks_nvme_controller_method_info_smart_selftest_start.parent_struct,
  &_udisks_nvme_controller_method_info_smart_selftest_abort.parent_struct,
  &_udisks_nvme_controller_method_info_sanitize_start.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_state =
{
  {
    -1,
    (gchar *) "State",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "state",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_controller_id =
{
  {
    -1,
    (gchar *) "ControllerID",
    (gchar *) "q",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "controller-id",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_subsystem_nqn =
{
  {
    -1,
    (gchar *) "SubsystemNQN",
    (gchar *) "ay",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "subsystem-nqn",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_fguid =
{
  {
    -1,
    (gchar *) "FGUID",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "fguid",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_nvme_revision =
{
  {
    -1,
    (gchar *) "NVMeRevision",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "nvme-revision",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_unallocated_capacity =
{
  {
    -1,
    (gchar *) "UnallocatedCapacity",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "unallocated-capacity",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_smart_updated =
{
  {
    -1,
    (gchar *) "SmartUpdated",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-updated",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_smart_critical_warning =
{
  {
    -1,
    (gchar *) "SmartCriticalWarning",
    (gchar *) "as",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-critical-warning",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_smart_power_on_hours =
{
  {
    -1,
    (gchar *) "SmartPowerOnHours",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-power-on-hours",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_smart_temperature =
{
  {
    -1,
    (gchar *) "SmartTemperature",
    (gchar *) "q",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-temperature",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_smart_selftest_status =
{
  {
    -1,
    (gchar *) "SmartSelftestStatus",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-selftest-status",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_smart_selftest_percent_remaining =
{
  {
    -1,
    (gchar *) "SmartSelftestPercentRemaining",
    (gchar *) "i",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "smart-selftest-percent-remaining",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_sanitize_status =
{
  {
    -1,
    (gchar *) "SanitizeStatus",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "sanitize-status",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_controller_property_info_sanitize_percent_remaining =
{
  {
    -1,
    (gchar *) "SanitizePercentRemaining",
    (gchar *) "i",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "sanitize-percent-remaining",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_nvme_controller_property_info_pointers[] =
{
  &_udisks_nvme_controller_property_info_state.parent_struct,
  &_udisks_nvme_controller_property_info_controller_id.parent_struct,
  &_udisks_nvme_controller_property_info_subsystem_nqn.parent_struct,
  &_udisks_nvme_controller_property_info_fguid.parent_struct,
  &_udisks_nvme_controller_property_info_nvme_revision.parent_struct,
  &_udisks_nvme_controller_property_info_unallocated_capacity.parent_struct,
  &_udisks_nvme_controller_property_info_smart_updated.parent_struct,
  &_udisks_nvme_controller_property_info_smart_critical_warning.parent_struct,
  &_udisks_nvme_controller_property_info_smart_power_on_hours.parent_struct,
  &_udisks_nvme_controller_property_info_smart_temperature.parent_struct,
  &_udisks_nvme_controller_property_info_smart_selftest_status.parent_struct,
  &_udisks_nvme_controller_property_info_smart_selftest_percent_remaining.parent_struct,
  &_udisks_nvme_controller_property_info_sanitize_status.parent_struct,
  &_udisks_nvme_controller_property_info_sanitize_percent_remaining.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_nvme_controller_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.NVMe.Controller",
    (GDBusMethodInfo **) &_udisks_nvme_controller_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_nvme_controller_property_info_pointers,
    NULL
  },
  "nvme-controller",
};


/**
 * udisks_nvme_controller_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Controller.top_of_page">org.freedesktop.UDisks2.NVMe.Controller</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_nvme_controller_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_nvme_controller_interface_info.parent_struct;
}

/**
 * udisks_nvme_controller_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksNVMeController interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_nvme_controller_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "state");
  g_object_class_override_property (klass, property_id_begin++, "controller-id");
  g_object_class_override_property (klass, property_id_begin++, "subsystem-nqn");
  g_object_class_override_property (klass, property_id_begin++, "fguid");
  g_object_class_override_property (klass, property_id_begin++, "nvme-revision");
  g_object_class_override_property (klass, property_id_begin++, "unallocated-capacity");
  g_object_class_override_property (klass, property_id_begin++, "smart-updated");
  g_object_class_override_property (klass, property_id_begin++, "smart-critical-warning");
  g_object_class_override_property (klass, property_id_begin++, "smart-power-on-hours");
  g_object_class_override_property (klass, property_id_begin++, "smart-temperature");
  g_object_class_override_property (klass, property_id_begin++, "smart-selftest-status");
  g_object_class_override_property (klass, property_id_begin++, "smart-selftest-percent-remaining");
  g_object_class_override_property (klass, property_id_begin++, "sanitize-status");
  g_object_class_override_property (klass, property_id_begin++, "sanitize-percent-remaining");
  return property_id_begin - 1;
}


inline static void
udisks_nvme_controller_method_marshal_smart_update (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_nvme_controller_method_marshal_smart_get_attributes (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_nvme_controller_method_marshal_smart_selftest_start (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_nvme_controller_method_marshal_smart_selftest_abort (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_nvme_controller_method_marshal_sanitize_start (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksNVMeController:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Controller.top_of_page">org.freedesktop.UDisks2.NVMe.Controller</link>.
 */

/**
 * UDisksNVMeControllerIface:
 * @parent_iface: The parent interface.
 * @get_controller_id: Getter for the #UDisksNVMeController:controller-id property.
 * @get_fguid: Getter for the #UDisksNVMeController:fguid property.
 * @get_nvme_revision: Getter for the #UDisksNVMeController:nvme-revision property.
 * @get_sanitize_status: Getter for the #UDisksNVMeController:sanitize-status property.
 * @get_smart_critical_warning: Getter for the #UDisksNVMeController:smart-critical-warning property.
 * @get_smart_power_on_hours: Getter for the #UDisksNVMeController:smart-power-on-hours property.
 * @get_smart_selftest_status: Getter for the #UDisksNVMeController:smart-selftest-status property.
 * @get_smart_temperature: Getter for the #UDisksNVMeController:smart-temperature property.
 * @get_smart_updated: Getter for the #UDisksNVMeController:smart-updated property.
 * @get_state: Getter for the #UDisksNVMeController:state property.
 * @get_subsystem_nqn: Getter for the #UDisksNVMeController:subsystem-nqn property.
 * @get_unallocated_capacity: Getter for the #UDisksNVMeController:unallocated-capacity property.
 * @handle_sanitize_start: Handler for the #UDisksNVMeController::handle-sanitize-start signal.
 * @handle_smart_get_attributes: Handler for the #UDisksNVMeController::handle-smart-get-attributes signal.
 * @handle_smart_selftest_abort: Handler for the #UDisksNVMeController::handle-smart-selftest-abort signal.
 * @handle_smart_selftest_start: Handler for the #UDisksNVMeController::handle-smart-selftest-start signal.
 * @handle_smart_update: Handler for the #UDisksNVMeController::handle-smart-update signal.
 * @get_sanitize_percent_remaining: Getter for the #UDisksNVMeController:sanitize-percent-remaining property.
 * @get_smart_selftest_percent_remaining: Getter for the #UDisksNVMeController:smart-selftest-percent-remaining property.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Controller.top_of_page">org.freedesktop.UDisks2.NVMe.Controller</link>.
 */

typedef UDisksNVMeControllerIface UDisksNVMeControllerInterface;
G_DEFINE_INTERFACE (UDisksNVMeController, udisks_nvme_controller, G_TYPE_OBJECT)

static void
udisks_nvme_controller_default_init (UDisksNVMeControllerIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksNVMeController::handle-smart-update:
   * @object: A #UDisksNVMeController.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartUpdate">SmartUpdate()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_nvme_controller_complete_smart_update() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.10.0
   */
  g_signal_new ("handle-smart-update",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksNVMeControllerIface, handle_smart_update),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_nvme_controller_method_marshal_smart_update,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksNVMeController::handle-smart-get-attributes:
   * @object: A #UDisksNVMeController.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartGetAttributes">SmartGetAttributes()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_nvme_controller_complete_smart_get_attributes() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.10.0
   */
  g_signal_new ("handle-smart-get-attributes",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksNVMeControllerIface, handle_smart_get_attributes),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_nvme_controller_method_marshal_smart_get_attributes,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksNVMeController::handle-smart-selftest-start:
   * @object: A #UDisksNVMeController.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_type: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestStart">SmartSelftestStart()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_nvme_controller_complete_smart_selftest_start() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.10.0
   */
  g_signal_new ("handle-smart-selftest-start",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksNVMeControllerIface, handle_smart_selftest_start),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_nvme_controller_method_marshal_smart_selftest_start,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksNVMeController::handle-smart-selftest-abort:
   * @object: A #UDisksNVMeController.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestAbort">SmartSelftestAbort()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_nvme_controller_complete_smart_selftest_abort() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.10.0
   */
  g_signal_new ("handle-smart-selftest-abort",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksNVMeControllerIface, handle_smart_selftest_abort),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_nvme_controller_method_marshal_smart_selftest_abort,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksNVMeController::handle-sanitize-start:
   * @object: A #UDisksNVMeController.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_action: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SanitizeStart">SanitizeStart()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_nvme_controller_complete_sanitize_start() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.10.0
   */
  g_signal_new ("handle-sanitize-start",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksNVMeControllerIface, handle_sanitize_start),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_nvme_controller_method_marshal_sanitize_start,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksNVMeController:state:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.State">"State"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("state", "State", "State", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeController:controller-id:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.ControllerID">"ControllerID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint ("controller-id", "ControllerID", "ControllerID", 0, G_MAXUINT16, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeController:subsystem-nqn:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SubsystemNQN">"SubsystemNQN"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("subsystem-nqn", "SubsystemNQN", "SubsystemNQN", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeController:fguid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.FGUID">"FGUID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("fguid", "FGUID", "FGUID", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeController:nvme-revision:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.NVMeRevision">"NVMeRevision"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("nvme-revision", "NVMeRevision", "NVMeRevision", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeController:unallocated-capacity:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.UnallocatedCapacity">"UnallocatedCapacity"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("unallocated-capacity", "UnallocatedCapacity", "UnallocatedCapacity", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeController:smart-updated:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartUpdated">"SmartUpdated"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("smart-updated", "SmartUpdated", "SmartUpdated", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeController:smart-critical-warning:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartCriticalWarning">"SmartCriticalWarning"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boxed ("smart-critical-warning", "SmartCriticalWarning", "SmartCriticalWarning", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeController:smart-power-on-hours:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartPowerOnHours">"SmartPowerOnHours"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("smart-power-on-hours", "SmartPowerOnHours", "SmartPowerOnHours", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeController:smart-temperature:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartTemperature">"SmartTemperature"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint ("smart-temperature", "SmartTemperature", "SmartTemperature", 0, G_MAXUINT16, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeController:smart-selftest-status:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestStatus">"SmartSelftestStatus"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("smart-selftest-status", "SmartSelftestStatus", "SmartSelftestStatus", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeController:smart-selftest-percent-remaining:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestPercentRemaining">"SmartSelftestPercentRemaining"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.10.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_int ("smart-selftest-percent-remaining", "SmartSelftestPercentRemaining", "SmartSelftestPercentRemaining", G_MININT32, G_MAXINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeController:sanitize-status:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SanitizeStatus">"SanitizeStatus"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("sanitize-status", "SanitizeStatus", "SanitizeStatus", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeController:sanitize-percent-remaining:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SanitizePercentRemaining">"SanitizePercentRemaining"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.10.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_int ("sanitize-percent-remaining", "SanitizePercentRemaining", "SanitizePercentRemaining", G_MININT32, G_MAXINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_nvme_controller_get_state: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.State">"State"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_controller_dup_state() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_controller_get_state (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), NULL);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_state (object);
}

/**
 * udisks_nvme_controller_dup_state: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.State">"State"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_controller_dup_state (UDisksNVMeController *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "state", &value, NULL);
  return value;
}

/**
 * udisks_nvme_controller_set_state: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.State">"State"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_controller_set_state (UDisksNVMeController *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "state", value, NULL);
}

/**
 * udisks_nvme_controller_get_controller_id: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.ControllerID">"ControllerID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint16 
udisks_nvme_controller_get_controller_id (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), 0);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_controller_id (object);
}

/**
 * udisks_nvme_controller_set_controller_id: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.ControllerID">"ControllerID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_controller_set_controller_id (UDisksNVMeController *object, guint16 value)
{
  g_object_set (G_OBJECT (object), "controller-id", value, NULL);
}

/**
 * udisks_nvme_controller_get_subsystem_nqn: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SubsystemNQN">"SubsystemNQN"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_controller_dup_subsystem_nqn() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_controller_get_subsystem_nqn (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), NULL);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_subsystem_nqn (object);
}

/**
 * udisks_nvme_controller_dup_subsystem_nqn: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SubsystemNQN">"SubsystemNQN"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_controller_dup_subsystem_nqn (UDisksNVMeController *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "subsystem-nqn", &value, NULL);
  return value;
}

/**
 * udisks_nvme_controller_set_subsystem_nqn: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SubsystemNQN">"SubsystemNQN"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_controller_set_subsystem_nqn (UDisksNVMeController *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "subsystem-nqn", value, NULL);
}

/**
 * udisks_nvme_controller_get_fguid: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.FGUID">"FGUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_controller_dup_fguid() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_controller_get_fguid (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), NULL);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_fguid (object);
}

/**
 * udisks_nvme_controller_dup_fguid: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.FGUID">"FGUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_controller_dup_fguid (UDisksNVMeController *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "fguid", &value, NULL);
  return value;
}

/**
 * udisks_nvme_controller_set_fguid: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.FGUID">"FGUID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_controller_set_fguid (UDisksNVMeController *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "fguid", value, NULL);
}

/**
 * udisks_nvme_controller_get_nvme_revision: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.NVMeRevision">"NVMeRevision"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_controller_dup_nvme_revision() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_controller_get_nvme_revision (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), NULL);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_nvme_revision (object);
}

/**
 * udisks_nvme_controller_dup_nvme_revision: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.NVMeRevision">"NVMeRevision"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_controller_dup_nvme_revision (UDisksNVMeController *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "nvme-revision", &value, NULL);
  return value;
}

/**
 * udisks_nvme_controller_set_nvme_revision: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.NVMeRevision">"NVMeRevision"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_controller_set_nvme_revision (UDisksNVMeController *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "nvme-revision", value, NULL);
}

/**
 * udisks_nvme_controller_get_unallocated_capacity: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.UnallocatedCapacity">"UnallocatedCapacity"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_nvme_controller_get_unallocated_capacity (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), 0);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_unallocated_capacity (object);
}

/**
 * udisks_nvme_controller_set_unallocated_capacity: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.UnallocatedCapacity">"UnallocatedCapacity"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_controller_set_unallocated_capacity (UDisksNVMeController *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "unallocated-capacity", value, NULL);
}

/**
 * udisks_nvme_controller_get_smart_updated: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartUpdated">"SmartUpdated"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_nvme_controller_get_smart_updated (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), 0);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_smart_updated (object);
}

/**
 * udisks_nvme_controller_set_smart_updated: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartUpdated">"SmartUpdated"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_controller_set_smart_updated (UDisksNVMeController *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "smart-updated", value, NULL);
}

/**
 * udisks_nvme_controller_get_smart_critical_warning: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartCriticalWarning">"SmartCriticalWarning"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_controller_dup_smart_critical_warning() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *const *
udisks_nvme_controller_get_smart_critical_warning (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), NULL);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_smart_critical_warning (object);
}

/**
 * udisks_nvme_controller_dup_smart_critical_warning: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartCriticalWarning">"SmartCriticalWarning"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_strfreev().
 */
gchar **
udisks_nvme_controller_dup_smart_critical_warning (UDisksNVMeController *object)
{
  gchar **value;
  g_object_get (G_OBJECT (object), "smart-critical-warning", &value, NULL);
  return value;
}

/**
 * udisks_nvme_controller_set_smart_critical_warning: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartCriticalWarning">"SmartCriticalWarning"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_controller_set_smart_critical_warning (UDisksNVMeController *object, const gchar *const *value)
{
  g_object_set (G_OBJECT (object), "smart-critical-warning", value, NULL);
}

/**
 * udisks_nvme_controller_get_smart_power_on_hours: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartPowerOnHours">"SmartPowerOnHours"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_nvme_controller_get_smart_power_on_hours (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), 0);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_smart_power_on_hours (object);
}

/**
 * udisks_nvme_controller_set_smart_power_on_hours: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartPowerOnHours">"SmartPowerOnHours"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_controller_set_smart_power_on_hours (UDisksNVMeController *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "smart-power-on-hours", value, NULL);
}

/**
 * udisks_nvme_controller_get_smart_temperature: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartTemperature">"SmartTemperature"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint16 
udisks_nvme_controller_get_smart_temperature (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), 0);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_smart_temperature (object);
}

/**
 * udisks_nvme_controller_set_smart_temperature: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartTemperature">"SmartTemperature"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_controller_set_smart_temperature (UDisksNVMeController *object, guint16 value)
{
  g_object_set (G_OBJECT (object), "smart-temperature", value, NULL);
}

/**
 * udisks_nvme_controller_get_smart_selftest_status: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestStatus">"SmartSelftestStatus"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_controller_dup_smart_selftest_status() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_controller_get_smart_selftest_status (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), NULL);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_smart_selftest_status (object);
}

/**
 * udisks_nvme_controller_dup_smart_selftest_status: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestStatus">"SmartSelftestStatus"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_controller_dup_smart_selftest_status (UDisksNVMeController *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "smart-selftest-status", &value, NULL);
  return value;
}

/**
 * udisks_nvme_controller_set_smart_selftest_status: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestStatus">"SmartSelftestStatus"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_controller_set_smart_selftest_status (UDisksNVMeController *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "smart-selftest-status", value, NULL);
}

/**
 * udisks_nvme_controller_get_smart_selftest_percent_remaining: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestPercentRemaining">"SmartSelftestPercentRemaining"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.10.0
 */
gint 
udisks_nvme_controller_get_smart_selftest_percent_remaining (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), 0);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_smart_selftest_percent_remaining (object);
}

/**
 * udisks_nvme_controller_set_smart_selftest_percent_remaining: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestPercentRemaining">"SmartSelftestPercentRemaining"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_controller_set_smart_selftest_percent_remaining (UDisksNVMeController *object, gint value)
{
  g_object_set (G_OBJECT (object), "smart-selftest-percent-remaining", value, NULL);
}

/**
 * udisks_nvme_controller_get_sanitize_status: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SanitizeStatus">"SanitizeStatus"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_controller_dup_sanitize_status() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_controller_get_sanitize_status (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), NULL);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_sanitize_status (object);
}

/**
 * udisks_nvme_controller_dup_sanitize_status: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SanitizeStatus">"SanitizeStatus"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_controller_dup_sanitize_status (UDisksNVMeController *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "sanitize-status", &value, NULL);
  return value;
}

/**
 * udisks_nvme_controller_set_sanitize_status: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SanitizeStatus">"SanitizeStatus"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_controller_set_sanitize_status (UDisksNVMeController *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "sanitize-status", value, NULL);
}

/**
 * udisks_nvme_controller_get_sanitize_percent_remaining: (skip)
 * @object: A #UDisksNVMeController.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SanitizePercentRemaining">"SanitizePercentRemaining"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.10.0
 */
gint 
udisks_nvme_controller_get_sanitize_percent_remaining (UDisksNVMeController *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_CONTROLLER (object), 0);

  return UDISKS_NVME_CONTROLLER_GET_IFACE (object)->get_sanitize_percent_remaining (object);
}

/**
 * udisks_nvme_controller_set_sanitize_percent_remaining: (skip)
 * @object: A #UDisksNVMeController.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Controller.SanitizePercentRemaining">"SanitizePercentRemaining"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_controller_set_sanitize_percent_remaining (UDisksNVMeController *object, gint value)
{
  g_object_set (G_OBJECT (object), "sanitize-percent-remaining", value, NULL);
}

/**
 * udisks_nvme_controller_call_smart_update:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartUpdate">SmartUpdate()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_nvme_controller_call_smart_update_finish() to get the result of the operation.
 *
 * See udisks_nvme_controller_call_smart_update_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_controller_call_smart_update (
    UDisksNVMeController *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SmartUpdate",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_nvme_controller_call_smart_update_finish:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_nvme_controller_call_smart_update().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_nvme_controller_call_smart_update().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_controller_call_smart_update_finish (
    UDisksNVMeController *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_controller_call_smart_update_sync:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartUpdate">SmartUpdate()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_nvme_controller_call_smart_update() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_controller_call_smart_update_sync (
    UDisksNVMeController *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SmartUpdate",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_controller_call_smart_get_attributes:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartGetAttributes">SmartGetAttributes()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_nvme_controller_call_smart_get_attributes_finish() to get the result of the operation.
 *
 * See udisks_nvme_controller_call_smart_get_attributes_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_controller_call_smart_get_attributes (
    UDisksNVMeController *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SmartGetAttributes",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_nvme_controller_call_smart_get_attributes_finish:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @out_attributes: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_nvme_controller_call_smart_get_attributes().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_nvme_controller_call_smart_get_attributes().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_controller_call_smart_get_attributes_finish (
    UDisksNVMeController *proxy,
    GVariant ** out_attributes,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@a{sv})",
                 out_attributes);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_controller_call_smart_get_attributes_sync:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @out_attributes: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartGetAttributes">SmartGetAttributes()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_nvme_controller_call_smart_get_attributes() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_controller_call_smart_get_attributes_sync (
    UDisksNVMeController *proxy,
    GVariant *arg_options,
    GVariant ** out_attributes,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SmartGetAttributes",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@a{sv})",
                 out_attributes);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_controller_call_smart_selftest_start:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestStart">SmartSelftestStart()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_nvme_controller_call_smart_selftest_start_finish() to get the result of the operation.
 *
 * See udisks_nvme_controller_call_smart_selftest_start_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_controller_call_smart_selftest_start (
    UDisksNVMeController *proxy,
    const gchar *arg_type,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SmartSelftestStart",
    g_variant_new ("(s@a{sv})",
                   arg_type,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_nvme_controller_call_smart_selftest_start_finish:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_nvme_controller_call_smart_selftest_start().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_nvme_controller_call_smart_selftest_start().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_controller_call_smart_selftest_start_finish (
    UDisksNVMeController *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_controller_call_smart_selftest_start_sync:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestStart">SmartSelftestStart()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_nvme_controller_call_smart_selftest_start() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_controller_call_smart_selftest_start_sync (
    UDisksNVMeController *proxy,
    const gchar *arg_type,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SmartSelftestStart",
    g_variant_new ("(s@a{sv})",
                   arg_type,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_controller_call_smart_selftest_abort:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestAbort">SmartSelftestAbort()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_nvme_controller_call_smart_selftest_abort_finish() to get the result of the operation.
 *
 * See udisks_nvme_controller_call_smart_selftest_abort_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_controller_call_smart_selftest_abort (
    UDisksNVMeController *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SmartSelftestAbort",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_nvme_controller_call_smart_selftest_abort_finish:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_nvme_controller_call_smart_selftest_abort().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_nvme_controller_call_smart_selftest_abort().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_controller_call_smart_selftest_abort_finish (
    UDisksNVMeController *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_controller_call_smart_selftest_abort_sync:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestAbort">SmartSelftestAbort()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_nvme_controller_call_smart_selftest_abort() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_controller_call_smart_selftest_abort_sync (
    UDisksNVMeController *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SmartSelftestAbort",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_controller_call_sanitize_start:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @arg_action: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SanitizeStart">SanitizeStart()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_nvme_controller_call_sanitize_start_finish() to get the result of the operation.
 *
 * See udisks_nvme_controller_call_sanitize_start_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_controller_call_sanitize_start (
    UDisksNVMeController *proxy,
    const gchar *arg_action,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SanitizeStart",
    g_variant_new ("(s@a{sv})",
                   arg_action,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_nvme_controller_call_sanitize_start_finish:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_nvme_controller_call_sanitize_start().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_nvme_controller_call_sanitize_start().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_controller_call_sanitize_start_finish (
    UDisksNVMeController *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_controller_call_sanitize_start_sync:
 * @proxy: A #UDisksNVMeControllerProxy.
 * @arg_action: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SanitizeStart">SanitizeStart()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_nvme_controller_call_sanitize_start() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_controller_call_sanitize_start_sync (
    UDisksNVMeController *proxy,
    const gchar *arg_action,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SanitizeStart",
    g_variant_new ("(s@a{sv})",
                   arg_action,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_controller_complete_smart_update:
 * @object: A #UDisksNVMeController.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartUpdate">SmartUpdate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_controller_complete_smart_update (
    UDisksNVMeController *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_nvme_controller_complete_smart_get_attributes:
 * @object: A #UDisksNVMeController.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @attributes: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartGetAttributes">SmartGetAttributes()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_controller_complete_smart_get_attributes (
    UDisksNVMeController *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GVariant *attributes)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(@a{sv})",
                   attributes));
}

/**
 * udisks_nvme_controller_complete_smart_selftest_start:
 * @object: A #UDisksNVMeController.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestStart">SmartSelftestStart()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_controller_complete_smart_selftest_start (
    UDisksNVMeController *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_nvme_controller_complete_smart_selftest_abort:
 * @object: A #UDisksNVMeController.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SmartSelftestAbort">SmartSelftestAbort()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_controller_complete_smart_selftest_abort (
    UDisksNVMeController *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_nvme_controller_complete_sanitize_start:
 * @object: A #UDisksNVMeController.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Controller.SanitizeStart">SanitizeStart()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_controller_complete_sanitize_start (
    UDisksNVMeController *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksNVMeControllerProxy:
 *
 * The #UDisksNVMeControllerProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksNVMeControllerProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksNVMeControllerProxy.
 */

struct _UDisksNVMeControllerProxyPrivate
{
  GData *qdata;
};

static void udisks_nvme_controller_proxy_iface_init (UDisksNVMeControllerIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksNVMeControllerProxy, udisks_nvme_controller_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksNVMeControllerProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_NVME_CONTROLLER, udisks_nvme_controller_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksNVMeControllerProxy, udisks_nvme_controller_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_NVME_CONTROLLER, udisks_nvme_controller_proxy_iface_init))

#endif
static void
udisks_nvme_controller_proxy_finalize (GObject *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_nvme_controller_proxy_parent_class)->finalize (object);
}

static void
udisks_nvme_controller_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 14);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_nvme_controller_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_nvme_controller_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.NVMe.Controller: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_nvme_controller_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 14);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_nvme_controller_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.NVMe.Controller", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_nvme_controller_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_nvme_controller_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_nvme_controller_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_NVME_CONTROLLER);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_NVME_CONTROLLER);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_nvme_controller_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_nvme_controller_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_nvme_controller_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_nvme_controller_proxy_get_state (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "State");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static guint16 
udisks_nvme_controller_proxy_get_controller_id (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  guint16 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ControllerID");
  if (variant != NULL)
    {
      value = g_variant_get_uint16 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_nvme_controller_proxy_get_subsystem_nqn (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SubsystemNQN");
  if (variant != NULL)
    {
      value = g_variant_get_bytestring (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_nvme_controller_proxy_get_fguid (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "FGUID");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_nvme_controller_proxy_get_nvme_revision (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "NVMeRevision");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_nvme_controller_proxy_get_unallocated_capacity (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "UnallocatedCapacity");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_nvme_controller_proxy_get_smart_updated (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartUpdated");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *const *
udisks_nvme_controller_proxy_get_smart_critical_warning (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  const gchar *const *value = NULL;
  value = g_datalist_get_data (&proxy->priv->qdata, "SmartCriticalWarning");
  if (value != NULL)
    return value;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartCriticalWarning");
  if (variant != NULL)
    {
      value = g_variant_get_strv (variant, NULL);
      g_datalist_set_data_full (&proxy->priv->qdata, "SmartCriticalWarning", (gpointer) value, g_free);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_nvme_controller_proxy_get_smart_power_on_hours (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartPowerOnHours");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint16 
udisks_nvme_controller_proxy_get_smart_temperature (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  guint16 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartTemperature");
  if (variant != NULL)
    {
      value = g_variant_get_uint16 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_nvme_controller_proxy_get_smart_selftest_status (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartSelftestStatus");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static gint 
udisks_nvme_controller_proxy_get_smart_selftest_percent_remaining (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  gint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SmartSelftestPercentRemaining");
  if (variant != NULL)
    {
      value = g_variant_get_int32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_nvme_controller_proxy_get_sanitize_status (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SanitizeStatus");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static gint 
udisks_nvme_controller_proxy_get_sanitize_percent_remaining (UDisksNVMeController *object)
{
  UDisksNVMeControllerProxy *proxy = UDISKS_NVME_CONTROLLER_PROXY (object);
  GVariant *variant;
  gint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SanitizePercentRemaining");
  if (variant != NULL)
    {
      value = g_variant_get_int32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_nvme_controller_proxy_init (UDisksNVMeControllerProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_nvme_controller_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_NVME_CONTROLLER_PROXY, UDisksNVMeControllerProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_nvme_controller_interface_info ());
}

static void
udisks_nvme_controller_proxy_class_init (UDisksNVMeControllerProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_nvme_controller_proxy_finalize;
  gobject_class->get_property = udisks_nvme_controller_proxy_get_property;
  gobject_class->set_property = udisks_nvme_controller_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_nvme_controller_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_nvme_controller_proxy_g_properties_changed;

  udisks_nvme_controller_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksNVMeControllerProxyPrivate));
#endif
}

static void
udisks_nvme_controller_proxy_iface_init (UDisksNVMeControllerIface *iface)
{
  iface->get_state = udisks_nvme_controller_proxy_get_state;
  iface->get_controller_id = udisks_nvme_controller_proxy_get_controller_id;
  iface->get_subsystem_nqn = udisks_nvme_controller_proxy_get_subsystem_nqn;
  iface->get_fguid = udisks_nvme_controller_proxy_get_fguid;
  iface->get_nvme_revision = udisks_nvme_controller_proxy_get_nvme_revision;
  iface->get_unallocated_capacity = udisks_nvme_controller_proxy_get_unallocated_capacity;
  iface->get_smart_updated = udisks_nvme_controller_proxy_get_smart_updated;
  iface->get_smart_critical_warning = udisks_nvme_controller_proxy_get_smart_critical_warning;
  iface->get_smart_power_on_hours = udisks_nvme_controller_proxy_get_smart_power_on_hours;
  iface->get_smart_temperature = udisks_nvme_controller_proxy_get_smart_temperature;
  iface->get_smart_selftest_status = udisks_nvme_controller_proxy_get_smart_selftest_status;
  iface->get_smart_selftest_percent_remaining = udisks_nvme_controller_proxy_get_smart_selftest_percent_remaining;
  iface->get_sanitize_status = udisks_nvme_controller_proxy_get_sanitize_status;
  iface->get_sanitize_percent_remaining = udisks_nvme_controller_proxy_get_sanitize_percent_remaining;
}

/**
 * udisks_nvme_controller_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Controller.top_of_page">org.freedesktop.UDisks2.NVMe.Controller</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_nvme_controller_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_nvme_controller_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_nvme_controller_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_NVME_CONTROLLER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.NVMe.Controller", NULL);
}

/**
 * udisks_nvme_controller_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_nvme_controller_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_nvme_controller_proxy_new().
 *
 * Returns: (transfer full) (type UDisksNVMeControllerProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksNVMeController *
udisks_nvme_controller_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_NVME_CONTROLLER (ret);
  else
    return NULL;
}

/**
 * udisks_nvme_controller_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Controller.top_of_page">org.freedesktop.UDisks2.NVMe.Controller</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_nvme_controller_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksNVMeControllerProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksNVMeController *
udisks_nvme_controller_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_NVME_CONTROLLER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.NVMe.Controller", NULL);
  if (ret != NULL)
    return UDISKS_NVME_CONTROLLER (ret);
  else
    return NULL;
}


/**
 * udisks_nvme_controller_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_nvme_controller_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_nvme_controller_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_nvme_controller_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_nvme_controller_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_NVME_CONTROLLER_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.NVMe.Controller", NULL);
}

/**
 * udisks_nvme_controller_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_nvme_controller_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_nvme_controller_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksNVMeControllerProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksNVMeController *
udisks_nvme_controller_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_NVME_CONTROLLER (ret);
  else
    return NULL;
}

/**
 * udisks_nvme_controller_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_nvme_controller_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_nvme_controller_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksNVMeControllerProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksNVMeController *
udisks_nvme_controller_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_NVME_CONTROLLER_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.NVMe.Controller", NULL);
  if (ret != NULL)
    return UDISKS_NVME_CONTROLLER (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksNVMeControllerSkeleton:
 *
 * The #UDisksNVMeControllerSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksNVMeControllerSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksNVMeControllerSkeleton.
 */

struct _UDisksNVMeControllerSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_nvme_controller_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_NVME_CONTROLLER);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_NVME_CONTROLLER);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_nvme_controller_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_nvme_controller_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_nvme_controller_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_nvme_controller_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_nvme_controller_skeleton_vtable =
{
  _udisks_nvme_controller_skeleton_handle_method_call,
  _udisks_nvme_controller_skeleton_handle_get_property,
  _udisks_nvme_controller_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_nvme_controller_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_nvme_controller_interface_info ();
}

static GDBusInterfaceVTable *
udisks_nvme_controller_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_nvme_controller_skeleton_vtable;
}

static GVariant *
udisks_nvme_controller_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_nvme_controller_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_nvme_controller_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_nvme_controller_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_nvme_controller_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.NVMe.Controller", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_nvme_controller_emit_changed (gpointer user_data);

static void
udisks_nvme_controller_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_nvme_controller_emit_changed (skeleton);
}

static void udisks_nvme_controller_skeleton_iface_init (UDisksNVMeControllerIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksNVMeControllerSkeleton, udisks_nvme_controller_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksNVMeControllerSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_NVME_CONTROLLER, udisks_nvme_controller_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksNVMeControllerSkeleton, udisks_nvme_controller_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_NVME_CONTROLLER, udisks_nvme_controller_skeleton_iface_init))

#endif
static void
udisks_nvme_controller_skeleton_finalize (GObject *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  guint n;
  for (n = 0; n < 14; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_nvme_controller_skeleton_parent_class)->finalize (object);
}

static void
udisks_nvme_controller_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 14);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_nvme_controller_emit_changed (gpointer user_data)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.NVMe.Controller",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_nvme_controller_schedule_emit_changed (UDisksNVMeControllerSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_nvme_controller_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_nvme_controller_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_nvme_controller_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_nvme_controller_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 14);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_nvme_controller_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_nvme_controller_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_nvme_controller_skeleton_init (UDisksNVMeControllerSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_nvme_controller_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_NVME_CONTROLLER_SKELETON, UDisksNVMeControllerSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 14);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_UINT);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[4], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[5], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[6], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[7], G_TYPE_STRV);
  g_value_init (&skeleton->priv->properties[8], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[9], G_TYPE_UINT);
  g_value_init (&skeleton->priv->properties[10], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[11], G_TYPE_INT);
  g_value_init (&skeleton->priv->properties[12], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[13], G_TYPE_INT);
}

static const gchar *
udisks_nvme_controller_skeleton_get_state (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint16 
udisks_nvme_controller_skeleton_get_controller_id (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  guint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_nvme_controller_skeleton_get_subsystem_nqn (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_nvme_controller_skeleton_get_fguid (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_nvme_controller_skeleton_get_nvme_revision (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[4]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_nvme_controller_skeleton_get_unallocated_capacity (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[5]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_nvme_controller_skeleton_get_smart_updated (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[6]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *const *
udisks_nvme_controller_skeleton_get_smart_critical_warning (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  const gchar *const *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boxed (&(skeleton->priv->properties[7]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_nvme_controller_skeleton_get_smart_power_on_hours (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[8]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint16 
udisks_nvme_controller_skeleton_get_smart_temperature (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  guint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint (&(skeleton->priv->properties[9]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_nvme_controller_skeleton_get_smart_selftest_status (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[10]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gint 
udisks_nvme_controller_skeleton_get_smart_selftest_percent_remaining (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  gint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_int (&(skeleton->priv->properties[11]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_nvme_controller_skeleton_get_sanitize_status (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[12]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gint 
udisks_nvme_controller_skeleton_get_sanitize_percent_remaining (UDisksNVMeController *object)
{
  UDisksNVMeControllerSkeleton *skeleton = UDISKS_NVME_CONTROLLER_SKELETON (object);
  gint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_int (&(skeleton->priv->properties[13]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_nvme_controller_skeleton_class_init (UDisksNVMeControllerSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_nvme_controller_skeleton_finalize;
  gobject_class->get_property = udisks_nvme_controller_skeleton_get_property;
  gobject_class->set_property = udisks_nvme_controller_skeleton_set_property;
  gobject_class->notify       = udisks_nvme_controller_skeleton_notify;


  udisks_nvme_controller_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_nvme_controller_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_nvme_controller_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_nvme_controller_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_nvme_controller_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksNVMeControllerSkeletonPrivate));
#endif
}

static void
udisks_nvme_controller_skeleton_iface_init (UDisksNVMeControllerIface *iface)
{
  iface->get_state = udisks_nvme_controller_skeleton_get_state;
  iface->get_controller_id = udisks_nvme_controller_skeleton_get_controller_id;
  iface->get_subsystem_nqn = udisks_nvme_controller_skeleton_get_subsystem_nqn;
  iface->get_fguid = udisks_nvme_controller_skeleton_get_fguid;
  iface->get_nvme_revision = udisks_nvme_controller_skeleton_get_nvme_revision;
  iface->get_unallocated_capacity = udisks_nvme_controller_skeleton_get_unallocated_capacity;
  iface->get_smart_updated = udisks_nvme_controller_skeleton_get_smart_updated;
  iface->get_smart_critical_warning = udisks_nvme_controller_skeleton_get_smart_critical_warning;
  iface->get_smart_power_on_hours = udisks_nvme_controller_skeleton_get_smart_power_on_hours;
  iface->get_smart_temperature = udisks_nvme_controller_skeleton_get_smart_temperature;
  iface->get_smart_selftest_status = udisks_nvme_controller_skeleton_get_smart_selftest_status;
  iface->get_smart_selftest_percent_remaining = udisks_nvme_controller_skeleton_get_smart_selftest_percent_remaining;
  iface->get_sanitize_status = udisks_nvme_controller_skeleton_get_sanitize_status;
  iface->get_sanitize_percent_remaining = udisks_nvme_controller_skeleton_get_sanitize_percent_remaining;
}

/**
 * udisks_nvme_controller_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Controller.top_of_page">org.freedesktop.UDisks2.NVMe.Controller</link>.
 *
 * Returns: (transfer full) (type UDisksNVMeControllerSkeleton): The skeleton object.
 */
UDisksNVMeController *
udisks_nvme_controller_skeleton_new (void)
{
  return UDISKS_NVME_CONTROLLER (g_object_new (UDISKS_TYPE_NVME_CONTROLLER_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.NVMe.Namespace
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksNVMeNamespace
 * @title: UDisksNVMeNamespace
 * @short_description: Generated C code for the org.freedesktop.UDisks2.NVMe.Namespace D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Namespace.top_of_page">org.freedesktop.UDisks2.NVMe.Namespace</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.NVMe.Namespace ---- */

static const _ExtendedGDBusArgInfo _udisks_nvme_namespace_method_info_format_namespace_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_nvme_namespace_method_info_format_namespace_IN_ARG_pointers[] =
{
  &_udisks_nvme_namespace_method_info_format_namespace_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_nvme_namespace_method_info_format_namespace =
{
  {
    -1,
    (gchar *) "FormatNamespace",
    (GDBusArgInfo **) &_udisks_nvme_namespace_method_info_format_namespace_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-format-namespace",
  FALSE
};

static const GDBusMethodInfo * const _udisks_nvme_namespace_method_info_pointers[] =
{
  &_udisks_nvme_namespace_method_info_format_namespace.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_namespace_property_info_nsid =
{
  {
    -1,
    (gchar *) "NSID",
    (gchar *) "u",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "nsid",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_namespace_property_info_nguid =
{
  {
    -1,
    (gchar *) "NGUID",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "nguid",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_namespace_property_info_eui64 =
{
  {
    -1,
    (gchar *) "EUI64",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "eui64",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_namespace_property_info_uuid =
{
  {
    -1,
    (gchar *) "UUID",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "uuid",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_namespace_property_info_wwn =
{
  {
    -1,
    (gchar *) "WWN",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "wwn",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_namespace_property_info_lbaformats =
{
  {
    -1,
    (gchar *) "LBAFormats",
    (gchar *) "a(qqy)",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "lbaformats",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_namespace_property_info_formatted_lbasize =
{
  {
    -1,
    (gchar *) "FormattedLBASize",
    (gchar *) "(qqy)",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "formatted-lbasize",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_namespace_property_info_namespace_size =
{
  {
    -1,
    (gchar *) "NamespaceSize",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "namespace-size",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_namespace_property_info_namespace_capacity =
{
  {
    -1,
    (gchar *) "NamespaceCapacity",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "namespace-capacity",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_namespace_property_info_namespace_utilization =
{
  {
    -1,
    (gchar *) "NamespaceUtilization",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "namespace-utilization",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_namespace_property_info_format_percent_remaining =
{
  {
    -1,
    (gchar *) "FormatPercentRemaining",
    (gchar *) "i",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "format-percent-remaining",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_nvme_namespace_property_info_pointers[] =
{
  &_udisks_nvme_namespace_property_info_nsid.parent_struct,
  &_udisks_nvme_namespace_property_info_nguid.parent_struct,
  &_udisks_nvme_namespace_property_info_eui64.parent_struct,
  &_udisks_nvme_namespace_property_info_uuid.parent_struct,
  &_udisks_nvme_namespace_property_info_wwn.parent_struct,
  &_udisks_nvme_namespace_property_info_lbaformats.parent_struct,
  &_udisks_nvme_namespace_property_info_formatted_lbasize.parent_struct,
  &_udisks_nvme_namespace_property_info_namespace_size.parent_struct,
  &_udisks_nvme_namespace_property_info_namespace_capacity.parent_struct,
  &_udisks_nvme_namespace_property_info_namespace_utilization.parent_struct,
  &_udisks_nvme_namespace_property_info_format_percent_remaining.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_nvme_namespace_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.NVMe.Namespace",
    (GDBusMethodInfo **) &_udisks_nvme_namespace_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_nvme_namespace_property_info_pointers,
    NULL
  },
  "nvme-namespace",
};


/**
 * udisks_nvme_namespace_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Namespace.top_of_page">org.freedesktop.UDisks2.NVMe.Namespace</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_nvme_namespace_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_nvme_namespace_interface_info.parent_struct;
}

/**
 * udisks_nvme_namespace_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksNVMeNamespace interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_nvme_namespace_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "nsid");
  g_object_class_override_property (klass, property_id_begin++, "nguid");
  g_object_class_override_property (klass, property_id_begin++, "eui64");
  g_object_class_override_property (klass, property_id_begin++, "uuid");
  g_object_class_override_property (klass, property_id_begin++, "wwn");
  g_object_class_override_property (klass, property_id_begin++, "lbaformats");
  g_object_class_override_property (klass, property_id_begin++, "formatted-lbasize");
  g_object_class_override_property (klass, property_id_begin++, "namespace-size");
  g_object_class_override_property (klass, property_id_begin++, "namespace-capacity");
  g_object_class_override_property (klass, property_id_begin++, "namespace-utilization");
  g_object_class_override_property (klass, property_id_begin++, "format-percent-remaining");
  return property_id_begin - 1;
}


inline static void
udisks_nvme_namespace_method_marshal_format_namespace (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksNVMeNamespace:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Namespace.top_of_page">org.freedesktop.UDisks2.NVMe.Namespace</link>.
 */

/**
 * UDisksNVMeNamespaceIface:
 * @parent_iface: The parent interface.
 * @get_eui64: Getter for the #UDisksNVMeNamespace:eui64 property.
 * @get_formatted_lbasize: Getter for the #UDisksNVMeNamespace:formatted-lbasize property.
 * @get_lbaformats: Getter for the #UDisksNVMeNamespace:lbaformats property.
 * @get_namespace_capacity: Getter for the #UDisksNVMeNamespace:namespace-capacity property.
 * @get_namespace_size: Getter for the #UDisksNVMeNamespace:namespace-size property.
 * @get_namespace_utilization: Getter for the #UDisksNVMeNamespace:namespace-utilization property.
 * @get_nguid: Getter for the #UDisksNVMeNamespace:nguid property.
 * @get_nsid: Getter for the #UDisksNVMeNamespace:nsid property.
 * @get_uuid: Getter for the #UDisksNVMeNamespace:uuid property.
 * @get_wwn: Getter for the #UDisksNVMeNamespace:wwn property.
 * @handle_format_namespace: Handler for the #UDisksNVMeNamespace::handle-format-namespace signal.
 * @get_format_percent_remaining: Getter for the #UDisksNVMeNamespace:format-percent-remaining property.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Namespace.top_of_page">org.freedesktop.UDisks2.NVMe.Namespace</link>.
 */

typedef UDisksNVMeNamespaceIface UDisksNVMeNamespaceInterface;
G_DEFINE_INTERFACE (UDisksNVMeNamespace, udisks_nvme_namespace, G_TYPE_OBJECT)

static void
udisks_nvme_namespace_default_init (UDisksNVMeNamespaceIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksNVMeNamespace::handle-format-namespace:
   * @object: A #UDisksNVMeNamespace.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Namespace.FormatNamespace">FormatNamespace()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_nvme_namespace_complete_format_namespace() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.10.0
   */
  g_signal_new ("handle-format-namespace",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksNVMeNamespaceIface, handle_format_namespace),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_nvme_namespace_method_marshal_format_namespace,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksNVMeNamespace:nsid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NSID">"NSID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint ("nsid", "NSID", "NSID", 0, G_MAXUINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeNamespace:nguid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NGUID">"NGUID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("nguid", "NGUID", "NGUID", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeNamespace:eui64:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.EUI64">"EUI64"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("eui64", "EUI64", "EUI64", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeNamespace:uuid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.UUID">"UUID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("uuid", "UUID", "UUID", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeNamespace:wwn:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.WWN">"WWN"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("wwn", "WWN", "WWN", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeNamespace:lbaformats:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.LBAFormats">"LBAFormats"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_variant ("lbaformats", "LBAFormats", "LBAFormats", G_VARIANT_TYPE ("a(qqy)"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeNamespace:formatted-lbasize:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.FormattedLBASize">"FormattedLBASize"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_variant ("formatted-lbasize", "FormattedLBASize", "FormattedLBASize", G_VARIANT_TYPE ("(qqy)"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeNamespace:namespace-size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NamespaceSize">"NamespaceSize"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("namespace-size", "NamespaceSize", "NamespaceSize", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeNamespace:namespace-capacity:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NamespaceCapacity">"NamespaceCapacity"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("namespace-capacity", "NamespaceCapacity", "NamespaceCapacity", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeNamespace:namespace-utilization:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NamespaceUtilization">"NamespaceUtilization"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("namespace-utilization", "NamespaceUtilization", "NamespaceUtilization", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeNamespace:format-percent-remaining:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.FormatPercentRemaining">"FormatPercentRemaining"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.10.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_int ("format-percent-remaining", "FormatPercentRemaining", "FormatPercentRemaining", G_MININT32, G_MAXINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_nvme_namespace_get_nsid: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NSID">"NSID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint 
udisks_nvme_namespace_get_nsid (UDisksNVMeNamespace *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_NAMESPACE (object), 0);

  return UDISKS_NVME_NAMESPACE_GET_IFACE (object)->get_nsid (object);
}

/**
 * udisks_nvme_namespace_set_nsid: (skip)
 * @object: A #UDisksNVMeNamespace.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NSID">"NSID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_namespace_set_nsid (UDisksNVMeNamespace *object, guint value)
{
  g_object_set (G_OBJECT (object), "nsid", value, NULL);
}

/**
 * udisks_nvme_namespace_get_nguid: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NGUID">"NGUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_namespace_dup_nguid() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_namespace_get_nguid (UDisksNVMeNamespace *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_NAMESPACE (object), NULL);

  return UDISKS_NVME_NAMESPACE_GET_IFACE (object)->get_nguid (object);
}

/**
 * udisks_nvme_namespace_dup_nguid: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NGUID">"NGUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_namespace_dup_nguid (UDisksNVMeNamespace *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "nguid", &value, NULL);
  return value;
}

/**
 * udisks_nvme_namespace_set_nguid: (skip)
 * @object: A #UDisksNVMeNamespace.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NGUID">"NGUID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_namespace_set_nguid (UDisksNVMeNamespace *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "nguid", value, NULL);
}

/**
 * udisks_nvme_namespace_get_eui64: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.EUI64">"EUI64"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_namespace_dup_eui64() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_namespace_get_eui64 (UDisksNVMeNamespace *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_NAMESPACE (object), NULL);

  return UDISKS_NVME_NAMESPACE_GET_IFACE (object)->get_eui64 (object);
}

/**
 * udisks_nvme_namespace_dup_eui64: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.EUI64">"EUI64"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_namespace_dup_eui64 (UDisksNVMeNamespace *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "eui64", &value, NULL);
  return value;
}

/**
 * udisks_nvme_namespace_set_eui64: (skip)
 * @object: A #UDisksNVMeNamespace.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.EUI64">"EUI64"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_namespace_set_eui64 (UDisksNVMeNamespace *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "eui64", value, NULL);
}

/**
 * udisks_nvme_namespace_get_uuid: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.UUID">"UUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_namespace_dup_uuid() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_namespace_get_uuid (UDisksNVMeNamespace *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_NAMESPACE (object), NULL);

  return UDISKS_NVME_NAMESPACE_GET_IFACE (object)->get_uuid (object);
}

/**
 * udisks_nvme_namespace_dup_uuid: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.UUID">"UUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_namespace_dup_uuid (UDisksNVMeNamespace *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "uuid", &value, NULL);
  return value;
}

/**
 * udisks_nvme_namespace_set_uuid: (skip)
 * @object: A #UDisksNVMeNamespace.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.UUID">"UUID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_namespace_set_uuid (UDisksNVMeNamespace *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "uuid", value, NULL);
}

/**
 * udisks_nvme_namespace_get_wwn: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.WWN">"WWN"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_namespace_dup_wwn() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_namespace_get_wwn (UDisksNVMeNamespace *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_NAMESPACE (object), NULL);

  return UDISKS_NVME_NAMESPACE_GET_IFACE (object)->get_wwn (object);
}

/**
 * udisks_nvme_namespace_dup_wwn: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.WWN">"WWN"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_namespace_dup_wwn (UDisksNVMeNamespace *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "wwn", &value, NULL);
  return value;
}

/**
 * udisks_nvme_namespace_set_wwn: (skip)
 * @object: A #UDisksNVMeNamespace.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.WWN">"WWN"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_namespace_set_wwn (UDisksNVMeNamespace *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "wwn", value, NULL);
}

/**
 * udisks_nvme_namespace_get_lbaformats: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.LBAFormats">"LBAFormats"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_namespace_dup_lbaformats() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
GVariant *
udisks_nvme_namespace_get_lbaformats (UDisksNVMeNamespace *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_NAMESPACE (object), NULL);

  return UDISKS_NVME_NAMESPACE_GET_IFACE (object)->get_lbaformats (object);
}

/**
 * udisks_nvme_namespace_dup_lbaformats: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.LBAFormats">"LBAFormats"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_variant_unref().
 */
GVariant *
udisks_nvme_namespace_dup_lbaformats (UDisksNVMeNamespace *object)
{
  GVariant *value;
  g_object_get (G_OBJECT (object), "lbaformats", &value, NULL);
  return value;
}

/**
 * udisks_nvme_namespace_set_lbaformats: (skip)
 * @object: A #UDisksNVMeNamespace.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.LBAFormats">"LBAFormats"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_namespace_set_lbaformats (UDisksNVMeNamespace *object, GVariant *value)
{
  g_object_set (G_OBJECT (object), "lbaformats", value, NULL);
}

/**
 * udisks_nvme_namespace_get_formatted_lbasize: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.FormattedLBASize">"FormattedLBASize"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_namespace_dup_formatted_lbasize() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
GVariant *
udisks_nvme_namespace_get_formatted_lbasize (UDisksNVMeNamespace *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_NAMESPACE (object), NULL);

  return UDISKS_NVME_NAMESPACE_GET_IFACE (object)->get_formatted_lbasize (object);
}

/**
 * udisks_nvme_namespace_dup_formatted_lbasize: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.FormattedLBASize">"FormattedLBASize"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_variant_unref().
 */
GVariant *
udisks_nvme_namespace_dup_formatted_lbasize (UDisksNVMeNamespace *object)
{
  GVariant *value;
  g_object_get (G_OBJECT (object), "formatted-lbasize", &value, NULL);
  return value;
}

/**
 * udisks_nvme_namespace_set_formatted_lbasize: (skip)
 * @object: A #UDisksNVMeNamespace.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.FormattedLBASize">"FormattedLBASize"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_namespace_set_formatted_lbasize (UDisksNVMeNamespace *object, GVariant *value)
{
  g_object_set (G_OBJECT (object), "formatted-lbasize", value, NULL);
}

/**
 * udisks_nvme_namespace_get_namespace_size: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NamespaceSize">"NamespaceSize"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_nvme_namespace_get_namespace_size (UDisksNVMeNamespace *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_NAMESPACE (object), 0);

  return UDISKS_NVME_NAMESPACE_GET_IFACE (object)->get_namespace_size (object);
}

/**
 * udisks_nvme_namespace_set_namespace_size: (skip)
 * @object: A #UDisksNVMeNamespace.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NamespaceSize">"NamespaceSize"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_namespace_set_namespace_size (UDisksNVMeNamespace *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "namespace-size", value, NULL);
}

/**
 * udisks_nvme_namespace_get_namespace_capacity: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NamespaceCapacity">"NamespaceCapacity"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_nvme_namespace_get_namespace_capacity (UDisksNVMeNamespace *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_NAMESPACE (object), 0);

  return UDISKS_NVME_NAMESPACE_GET_IFACE (object)->get_namespace_capacity (object);
}

/**
 * udisks_nvme_namespace_set_namespace_capacity: (skip)
 * @object: A #UDisksNVMeNamespace.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NamespaceCapacity">"NamespaceCapacity"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_namespace_set_namespace_capacity (UDisksNVMeNamespace *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "namespace-capacity", value, NULL);
}

/**
 * udisks_nvme_namespace_get_namespace_utilization: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NamespaceUtilization">"NamespaceUtilization"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_nvme_namespace_get_namespace_utilization (UDisksNVMeNamespace *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_NAMESPACE (object), 0);

  return UDISKS_NVME_NAMESPACE_GET_IFACE (object)->get_namespace_utilization (object);
}

/**
 * udisks_nvme_namespace_set_namespace_utilization: (skip)
 * @object: A #UDisksNVMeNamespace.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.NamespaceUtilization">"NamespaceUtilization"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_namespace_set_namespace_utilization (UDisksNVMeNamespace *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "namespace-utilization", value, NULL);
}

/**
 * udisks_nvme_namespace_get_format_percent_remaining: (skip)
 * @object: A #UDisksNVMeNamespace.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.FormatPercentRemaining">"FormatPercentRemaining"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.10.0
 */
gint 
udisks_nvme_namespace_get_format_percent_remaining (UDisksNVMeNamespace *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_NAMESPACE (object), 0);

  return UDISKS_NVME_NAMESPACE_GET_IFACE (object)->get_format_percent_remaining (object);
}

/**
 * udisks_nvme_namespace_set_format_percent_remaining: (skip)
 * @object: A #UDisksNVMeNamespace.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Namespace.FormatPercentRemaining">"FormatPercentRemaining"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_namespace_set_format_percent_remaining (UDisksNVMeNamespace *object, gint value)
{
  g_object_set (G_OBJECT (object), "format-percent-remaining", value, NULL);
}

/**
 * udisks_nvme_namespace_call_format_namespace:
 * @proxy: A #UDisksNVMeNamespaceProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Namespace.FormatNamespace">FormatNamespace()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_nvme_namespace_call_format_namespace_finish() to get the result of the operation.
 *
 * See udisks_nvme_namespace_call_format_namespace_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_namespace_call_format_namespace (
    UDisksNVMeNamespace *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "FormatNamespace",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_nvme_namespace_call_format_namespace_finish:
 * @proxy: A #UDisksNVMeNamespaceProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_nvme_namespace_call_format_namespace().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_nvme_namespace_call_format_namespace().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_namespace_call_format_namespace_finish (
    UDisksNVMeNamespace *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_namespace_call_format_namespace_sync:
 * @proxy: A #UDisksNVMeNamespaceProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Namespace.FormatNamespace">FormatNamespace()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_nvme_namespace_call_format_namespace() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_namespace_call_format_namespace_sync (
    UDisksNVMeNamespace *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "FormatNamespace",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_namespace_complete_format_namespace:
 * @object: A #UDisksNVMeNamespace.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Namespace.FormatNamespace">FormatNamespace()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_namespace_complete_format_namespace (
    UDisksNVMeNamespace *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksNVMeNamespaceProxy:
 *
 * The #UDisksNVMeNamespaceProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksNVMeNamespaceProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksNVMeNamespaceProxy.
 */

struct _UDisksNVMeNamespaceProxyPrivate
{
  GData *qdata;
};

static void udisks_nvme_namespace_proxy_iface_init (UDisksNVMeNamespaceIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksNVMeNamespaceProxy, udisks_nvme_namespace_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksNVMeNamespaceProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_NVME_NAMESPACE, udisks_nvme_namespace_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksNVMeNamespaceProxy, udisks_nvme_namespace_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_NVME_NAMESPACE, udisks_nvme_namespace_proxy_iface_init))

#endif
static void
udisks_nvme_namespace_proxy_finalize (GObject *object)
{
  UDisksNVMeNamespaceProxy *proxy = UDISKS_NVME_NAMESPACE_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_nvme_namespace_proxy_parent_class)->finalize (object);
}

static void
udisks_nvme_namespace_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 11);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_nvme_namespace_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_nvme_namespace_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.NVMe.Namespace: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_nvme_namespace_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 11);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_nvme_namespace_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.NVMe.Namespace", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_nvme_namespace_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_nvme_namespace_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_nvme_namespace_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_NVME_NAMESPACE);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_NVME_NAMESPACE);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_nvme_namespace_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksNVMeNamespaceProxy *proxy = UDISKS_NVME_NAMESPACE_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_nvme_namespace_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_nvme_namespace_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static guint 
udisks_nvme_namespace_proxy_get_nsid (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceProxy *proxy = UDISKS_NVME_NAMESPACE_PROXY (object);
  GVariant *variant;
  guint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "NSID");
  if (variant != NULL)
    {
      value = g_variant_get_uint32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_nvme_namespace_proxy_get_nguid (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceProxy *proxy = UDISKS_NVME_NAMESPACE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "NGUID");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_nvme_namespace_proxy_get_eui64 (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceProxy *proxy = UDISKS_NVME_NAMESPACE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "EUI64");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_nvme_namespace_proxy_get_uuid (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceProxy *proxy = UDISKS_NVME_NAMESPACE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "UUID");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_nvme_namespace_proxy_get_wwn (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceProxy *proxy = UDISKS_NVME_NAMESPACE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "WWN");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static GVariant *
udisks_nvme_namespace_proxy_get_lbaformats (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceProxy *proxy = UDISKS_NVME_NAMESPACE_PROXY (object);
  GVariant *variant;
  GVariant *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "LBAFormats");
  value = variant;
  if (variant != NULL)
    g_variant_unref (variant);
  return value;
}

static GVariant *
udisks_nvme_namespace_proxy_get_formatted_lbasize (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceProxy *proxy = UDISKS_NVME_NAMESPACE_PROXY (object);
  GVariant *variant;
  GVariant *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "FormattedLBASize");
  value = variant;
  if (variant != NULL)
    g_variant_unref (variant);
  return value;
}

static guint64 
udisks_nvme_namespace_proxy_get_namespace_size (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceProxy *proxy = UDISKS_NVME_NAMESPACE_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "NamespaceSize");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_nvme_namespace_proxy_get_namespace_capacity (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceProxy *proxy = UDISKS_NVME_NAMESPACE_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "NamespaceCapacity");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_nvme_namespace_proxy_get_namespace_utilization (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceProxy *proxy = UDISKS_NVME_NAMESPACE_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "NamespaceUtilization");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gint 
udisks_nvme_namespace_proxy_get_format_percent_remaining (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceProxy *proxy = UDISKS_NVME_NAMESPACE_PROXY (object);
  GVariant *variant;
  gint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "FormatPercentRemaining");
  if (variant != NULL)
    {
      value = g_variant_get_int32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_nvme_namespace_proxy_init (UDisksNVMeNamespaceProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_nvme_namespace_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_NVME_NAMESPACE_PROXY, UDisksNVMeNamespaceProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_nvme_namespace_interface_info ());
}

static void
udisks_nvme_namespace_proxy_class_init (UDisksNVMeNamespaceProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_nvme_namespace_proxy_finalize;
  gobject_class->get_property = udisks_nvme_namespace_proxy_get_property;
  gobject_class->set_property = udisks_nvme_namespace_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_nvme_namespace_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_nvme_namespace_proxy_g_properties_changed;

  udisks_nvme_namespace_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksNVMeNamespaceProxyPrivate));
#endif
}

static void
udisks_nvme_namespace_proxy_iface_init (UDisksNVMeNamespaceIface *iface)
{
  iface->get_nsid = udisks_nvme_namespace_proxy_get_nsid;
  iface->get_nguid = udisks_nvme_namespace_proxy_get_nguid;
  iface->get_eui64 = udisks_nvme_namespace_proxy_get_eui64;
  iface->get_uuid = udisks_nvme_namespace_proxy_get_uuid;
  iface->get_wwn = udisks_nvme_namespace_proxy_get_wwn;
  iface->get_lbaformats = udisks_nvme_namespace_proxy_get_lbaformats;
  iface->get_formatted_lbasize = udisks_nvme_namespace_proxy_get_formatted_lbasize;
  iface->get_namespace_size = udisks_nvme_namespace_proxy_get_namespace_size;
  iface->get_namespace_capacity = udisks_nvme_namespace_proxy_get_namespace_capacity;
  iface->get_namespace_utilization = udisks_nvme_namespace_proxy_get_namespace_utilization;
  iface->get_format_percent_remaining = udisks_nvme_namespace_proxy_get_format_percent_remaining;
}

/**
 * udisks_nvme_namespace_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Namespace.top_of_page">org.freedesktop.UDisks2.NVMe.Namespace</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_nvme_namespace_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_nvme_namespace_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_nvme_namespace_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_NVME_NAMESPACE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.NVMe.Namespace", NULL);
}

/**
 * udisks_nvme_namespace_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_nvme_namespace_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_nvme_namespace_proxy_new().
 *
 * Returns: (transfer full) (type UDisksNVMeNamespaceProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksNVMeNamespace *
udisks_nvme_namespace_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_NVME_NAMESPACE (ret);
  else
    return NULL;
}

/**
 * udisks_nvme_namespace_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Namespace.top_of_page">org.freedesktop.UDisks2.NVMe.Namespace</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_nvme_namespace_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksNVMeNamespaceProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksNVMeNamespace *
udisks_nvme_namespace_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_NVME_NAMESPACE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.NVMe.Namespace", NULL);
  if (ret != NULL)
    return UDISKS_NVME_NAMESPACE (ret);
  else
    return NULL;
}


/**
 * udisks_nvme_namespace_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_nvme_namespace_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_nvme_namespace_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_nvme_namespace_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_nvme_namespace_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_NVME_NAMESPACE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.NVMe.Namespace", NULL);
}

/**
 * udisks_nvme_namespace_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_nvme_namespace_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_nvme_namespace_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksNVMeNamespaceProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksNVMeNamespace *
udisks_nvme_namespace_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_NVME_NAMESPACE (ret);
  else
    return NULL;
}

/**
 * udisks_nvme_namespace_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_nvme_namespace_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_nvme_namespace_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksNVMeNamespaceProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksNVMeNamespace *
udisks_nvme_namespace_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_NVME_NAMESPACE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.NVMe.Namespace", NULL);
  if (ret != NULL)
    return UDISKS_NVME_NAMESPACE (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksNVMeNamespaceSkeleton:
 *
 * The #UDisksNVMeNamespaceSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksNVMeNamespaceSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksNVMeNamespaceSkeleton.
 */

struct _UDisksNVMeNamespaceSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_nvme_namespace_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_NVME_NAMESPACE);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_NVME_NAMESPACE);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_nvme_namespace_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_nvme_namespace_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_nvme_namespace_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_nvme_namespace_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_nvme_namespace_skeleton_vtable =
{
  _udisks_nvme_namespace_skeleton_handle_method_call,
  _udisks_nvme_namespace_skeleton_handle_get_property,
  _udisks_nvme_namespace_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_nvme_namespace_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_nvme_namespace_interface_info ();
}

static GDBusInterfaceVTable *
udisks_nvme_namespace_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_nvme_namespace_skeleton_vtable;
}

static GVariant *
udisks_nvme_namespace_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_nvme_namespace_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_nvme_namespace_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_nvme_namespace_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_nvme_namespace_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.NVMe.Namespace", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_nvme_namespace_emit_changed (gpointer user_data);

static void
udisks_nvme_namespace_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_nvme_namespace_emit_changed (skeleton);
}

static void udisks_nvme_namespace_skeleton_iface_init (UDisksNVMeNamespaceIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksNVMeNamespaceSkeleton, udisks_nvme_namespace_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksNVMeNamespaceSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_NVME_NAMESPACE, udisks_nvme_namespace_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksNVMeNamespaceSkeleton, udisks_nvme_namespace_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_NVME_NAMESPACE, udisks_nvme_namespace_skeleton_iface_init))

#endif
static void
udisks_nvme_namespace_skeleton_finalize (GObject *object)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  guint n;
  for (n = 0; n < 11; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_nvme_namespace_skeleton_parent_class)->finalize (object);
}

static void
udisks_nvme_namespace_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 11);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_nvme_namespace_emit_changed (gpointer user_data)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.NVMe.Namespace",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_nvme_namespace_schedule_emit_changed (UDisksNVMeNamespaceSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_nvme_namespace_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_nvme_namespace_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_nvme_namespace_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_nvme_namespace_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 11);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_nvme_namespace_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_nvme_namespace_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_nvme_namespace_skeleton_init (UDisksNVMeNamespaceSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_nvme_namespace_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_NVME_NAMESPACE_SKELETON, UDisksNVMeNamespaceSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 11);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_UINT);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[4], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[5], G_TYPE_VARIANT);
  g_value_init (&skeleton->priv->properties[6], G_TYPE_VARIANT);
  g_value_init (&skeleton->priv->properties[7], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[8], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[9], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[10], G_TYPE_INT);
}

static guint 
udisks_nvme_namespace_skeleton_get_nsid (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  guint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_nvme_namespace_skeleton_get_nguid (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_nvme_namespace_skeleton_get_eui64 (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_nvme_namespace_skeleton_get_uuid (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_nvme_namespace_skeleton_get_wwn (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[4]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static GVariant *
udisks_nvme_namespace_skeleton_get_lbaformats (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  GVariant *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_variant (&(skeleton->priv->properties[5]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static GVariant *
udisks_nvme_namespace_skeleton_get_formatted_lbasize (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  GVariant *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_variant (&(skeleton->priv->properties[6]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_nvme_namespace_skeleton_get_namespace_size (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[7]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_nvme_namespace_skeleton_get_namespace_capacity (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[8]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_nvme_namespace_skeleton_get_namespace_utilization (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[9]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gint 
udisks_nvme_namespace_skeleton_get_format_percent_remaining (UDisksNVMeNamespace *object)
{
  UDisksNVMeNamespaceSkeleton *skeleton = UDISKS_NVME_NAMESPACE_SKELETON (object);
  gint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_int (&(skeleton->priv->properties[10]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_nvme_namespace_skeleton_class_init (UDisksNVMeNamespaceSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_nvme_namespace_skeleton_finalize;
  gobject_class->get_property = udisks_nvme_namespace_skeleton_get_property;
  gobject_class->set_property = udisks_nvme_namespace_skeleton_set_property;
  gobject_class->notify       = udisks_nvme_namespace_skeleton_notify;


  udisks_nvme_namespace_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_nvme_namespace_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_nvme_namespace_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_nvme_namespace_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_nvme_namespace_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksNVMeNamespaceSkeletonPrivate));
#endif
}

static void
udisks_nvme_namespace_skeleton_iface_init (UDisksNVMeNamespaceIface *iface)
{
  iface->get_nsid = udisks_nvme_namespace_skeleton_get_nsid;
  iface->get_nguid = udisks_nvme_namespace_skeleton_get_nguid;
  iface->get_eui64 = udisks_nvme_namespace_skeleton_get_eui64;
  iface->get_uuid = udisks_nvme_namespace_skeleton_get_uuid;
  iface->get_wwn = udisks_nvme_namespace_skeleton_get_wwn;
  iface->get_lbaformats = udisks_nvme_namespace_skeleton_get_lbaformats;
  iface->get_formatted_lbasize = udisks_nvme_namespace_skeleton_get_formatted_lbasize;
  iface->get_namespace_size = udisks_nvme_namespace_skeleton_get_namespace_size;
  iface->get_namespace_capacity = udisks_nvme_namespace_skeleton_get_namespace_capacity;
  iface->get_namespace_utilization = udisks_nvme_namespace_skeleton_get_namespace_utilization;
  iface->get_format_percent_remaining = udisks_nvme_namespace_skeleton_get_format_percent_remaining;
}

/**
 * udisks_nvme_namespace_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Namespace.top_of_page">org.freedesktop.UDisks2.NVMe.Namespace</link>.
 *
 * Returns: (transfer full) (type UDisksNVMeNamespaceSkeleton): The skeleton object.
 */
UDisksNVMeNamespace *
udisks_nvme_namespace_skeleton_new (void)
{
  return UDISKS_NVME_NAMESPACE (g_object_new (UDISKS_TYPE_NVME_NAMESPACE_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.NVMe.Fabrics
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksNVMeFabrics
 * @title: UDisksNVMeFabrics
 * @short_description: Generated C code for the org.freedesktop.UDisks2.NVMe.Fabrics D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Fabrics.top_of_page">org.freedesktop.UDisks2.NVMe.Fabrics</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.NVMe.Fabrics ---- */

static const _ExtendedGDBusArgInfo _udisks_nvme_fabrics_method_info_disconnect_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_nvme_fabrics_method_info_disconnect_IN_ARG_pointers[] =
{
  &_udisks_nvme_fabrics_method_info_disconnect_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_nvme_fabrics_method_info_disconnect =
{
  {
    -1,
    (gchar *) "Disconnect",
    (GDBusArgInfo **) &_udisks_nvme_fabrics_method_info_disconnect_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-disconnect",
  FALSE
};

static const GDBusMethodInfo * const _udisks_nvme_fabrics_method_info_pointers[] =
{
  &_udisks_nvme_fabrics_method_info_disconnect.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_fabrics_property_info_host_nqn =
{
  {
    -1,
    (gchar *) "HostNQN",
    (gchar *) "ay",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "host-nqn",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_fabrics_property_info_host_id =
{
  {
    -1,
    (gchar *) "HostID",
    (gchar *) "ay",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "host-id",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_fabrics_property_info_transport =
{
  {
    -1,
    (gchar *) "Transport",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "transport",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_nvme_fabrics_property_info_transport_address =
{
  {
    -1,
    (gchar *) "TransportAddress",
    (gchar *) "ay",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "transport-address",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_nvme_fabrics_property_info_pointers[] =
{
  &_udisks_nvme_fabrics_property_info_host_nqn.parent_struct,
  &_udisks_nvme_fabrics_property_info_host_id.parent_struct,
  &_udisks_nvme_fabrics_property_info_transport.parent_struct,
  &_udisks_nvme_fabrics_property_info_transport_address.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_nvme_fabrics_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.NVMe.Fabrics",
    (GDBusMethodInfo **) &_udisks_nvme_fabrics_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_nvme_fabrics_property_info_pointers,
    NULL
  },
  "nvme-fabrics",
};


/**
 * udisks_nvme_fabrics_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Fabrics.top_of_page">org.freedesktop.UDisks2.NVMe.Fabrics</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_nvme_fabrics_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_nvme_fabrics_interface_info.parent_struct;
}

/**
 * udisks_nvme_fabrics_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksNVMeFabrics interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_nvme_fabrics_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "host-nqn");
  g_object_class_override_property (klass, property_id_begin++, "host-id");
  g_object_class_override_property (klass, property_id_begin++, "transport");
  g_object_class_override_property (klass, property_id_begin++, "transport-address");
  return property_id_begin - 1;
}


inline static void
udisks_nvme_fabrics_method_marshal_disconnect (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksNVMeFabrics:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Fabrics.top_of_page">org.freedesktop.UDisks2.NVMe.Fabrics</link>.
 */

/**
 * UDisksNVMeFabricsIface:
 * @parent_iface: The parent interface.
 * @get_host_id: Getter for the #UDisksNVMeFabrics:host-id property.
 * @get_host_nqn: Getter for the #UDisksNVMeFabrics:host-nqn property.
 * @get_transport: Getter for the #UDisksNVMeFabrics:transport property.
 * @get_transport_address: Getter for the #UDisksNVMeFabrics:transport-address property.
 * @handle_disconnect: Handler for the #UDisksNVMeFabrics::handle-disconnect signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Fabrics.top_of_page">org.freedesktop.UDisks2.NVMe.Fabrics</link>.
 */

typedef UDisksNVMeFabricsIface UDisksNVMeFabricsInterface;
G_DEFINE_INTERFACE (UDisksNVMeFabrics, udisks_nvme_fabrics, G_TYPE_OBJECT)

static void
udisks_nvme_fabrics_default_init (UDisksNVMeFabricsIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksNVMeFabrics::handle-disconnect:
   * @object: A #UDisksNVMeFabrics.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Fabrics.Disconnect">Disconnect()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_nvme_fabrics_complete_disconnect() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.10.0
   */
  g_signal_new ("handle-disconnect",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksNVMeFabricsIface, handle_disconnect),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_nvme_fabrics_method_marshal_disconnect,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksNVMeFabrics:host-nqn:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.HostNQN">"HostNQN"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("host-nqn", "HostNQN", "HostNQN", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeFabrics:host-id:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.HostID">"HostID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("host-id", "HostID", "HostID", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeFabrics:transport:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.Transport">"Transport"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("transport", "Transport", "Transport", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksNVMeFabrics:transport-address:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.TransportAddress">"TransportAddress"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("transport-address", "TransportAddress", "TransportAddress", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_nvme_fabrics_get_host_nqn: (skip)
 * @object: A #UDisksNVMeFabrics.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.HostNQN">"HostNQN"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_fabrics_dup_host_nqn() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_fabrics_get_host_nqn (UDisksNVMeFabrics *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_FABRICS (object), NULL);

  return UDISKS_NVME_FABRICS_GET_IFACE (object)->get_host_nqn (object);
}

/**
 * udisks_nvme_fabrics_dup_host_nqn: (skip)
 * @object: A #UDisksNVMeFabrics.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.HostNQN">"HostNQN"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_fabrics_dup_host_nqn (UDisksNVMeFabrics *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "host-nqn", &value, NULL);
  return value;
}

/**
 * udisks_nvme_fabrics_set_host_nqn: (skip)
 * @object: A #UDisksNVMeFabrics.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.HostNQN">"HostNQN"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_fabrics_set_host_nqn (UDisksNVMeFabrics *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "host-nqn", value, NULL);
}

/**
 * udisks_nvme_fabrics_get_host_id: (skip)
 * @object: A #UDisksNVMeFabrics.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.HostID">"HostID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_fabrics_dup_host_id() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_fabrics_get_host_id (UDisksNVMeFabrics *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_FABRICS (object), NULL);

  return UDISKS_NVME_FABRICS_GET_IFACE (object)->get_host_id (object);
}

/**
 * udisks_nvme_fabrics_dup_host_id: (skip)
 * @object: A #UDisksNVMeFabrics.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.HostID">"HostID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_fabrics_dup_host_id (UDisksNVMeFabrics *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "host-id", &value, NULL);
  return value;
}

/**
 * udisks_nvme_fabrics_set_host_id: (skip)
 * @object: A #UDisksNVMeFabrics.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.HostID">"HostID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_fabrics_set_host_id (UDisksNVMeFabrics *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "host-id", value, NULL);
}

/**
 * udisks_nvme_fabrics_get_transport: (skip)
 * @object: A #UDisksNVMeFabrics.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.Transport">"Transport"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_fabrics_dup_transport() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_fabrics_get_transport (UDisksNVMeFabrics *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_FABRICS (object), NULL);

  return UDISKS_NVME_FABRICS_GET_IFACE (object)->get_transport (object);
}

/**
 * udisks_nvme_fabrics_dup_transport: (skip)
 * @object: A #UDisksNVMeFabrics.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.Transport">"Transport"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_fabrics_dup_transport (UDisksNVMeFabrics *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "transport", &value, NULL);
  return value;
}

/**
 * udisks_nvme_fabrics_set_transport: (skip)
 * @object: A #UDisksNVMeFabrics.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.Transport">"Transport"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_fabrics_set_transport (UDisksNVMeFabrics *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "transport", value, NULL);
}

/**
 * udisks_nvme_fabrics_get_transport_address: (skip)
 * @object: A #UDisksNVMeFabrics.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.TransportAddress">"TransportAddress"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_nvme_fabrics_dup_transport_address() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_nvme_fabrics_get_transport_address (UDisksNVMeFabrics *object)
{
  g_return_val_if_fail (UDISKS_IS_NVME_FABRICS (object), NULL);

  return UDISKS_NVME_FABRICS_GET_IFACE (object)->get_transport_address (object);
}

/**
 * udisks_nvme_fabrics_dup_transport_address: (skip)
 * @object: A #UDisksNVMeFabrics.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.TransportAddress">"TransportAddress"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_nvme_fabrics_dup_transport_address (UDisksNVMeFabrics *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "transport-address", &value, NULL);
  return value;
}

/**
 * udisks_nvme_fabrics_set_transport_address: (skip)
 * @object: A #UDisksNVMeFabrics.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-NVMe-Fabrics.TransportAddress">"TransportAddress"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_nvme_fabrics_set_transport_address (UDisksNVMeFabrics *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "transport-address", value, NULL);
}

/**
 * udisks_nvme_fabrics_call_disconnect:
 * @proxy: A #UDisksNVMeFabricsProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Fabrics.Disconnect">Disconnect()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_nvme_fabrics_call_disconnect_finish() to get the result of the operation.
 *
 * See udisks_nvme_fabrics_call_disconnect_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_fabrics_call_disconnect (
    UDisksNVMeFabrics *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Disconnect",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_nvme_fabrics_call_disconnect_finish:
 * @proxy: A #UDisksNVMeFabricsProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_nvme_fabrics_call_disconnect().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_nvme_fabrics_call_disconnect().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_fabrics_call_disconnect_finish (
    UDisksNVMeFabrics *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_fabrics_call_disconnect_sync:
 * @proxy: A #UDisksNVMeFabricsProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Fabrics.Disconnect">Disconnect()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_nvme_fabrics_call_disconnect() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_nvme_fabrics_call_disconnect_sync (
    UDisksNVMeFabrics *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Disconnect",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_nvme_fabrics_complete_disconnect:
 * @object: A #UDisksNVMeFabrics.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-NVMe-Fabrics.Disconnect">Disconnect()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.10.0
 */
void
udisks_nvme_fabrics_complete_disconnect (
    UDisksNVMeFabrics *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksNVMeFabricsProxy:
 *
 * The #UDisksNVMeFabricsProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksNVMeFabricsProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksNVMeFabricsProxy.
 */

struct _UDisksNVMeFabricsProxyPrivate
{
  GData *qdata;
};

static void udisks_nvme_fabrics_proxy_iface_init (UDisksNVMeFabricsIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksNVMeFabricsProxy, udisks_nvme_fabrics_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksNVMeFabricsProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_NVME_FABRICS, udisks_nvme_fabrics_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksNVMeFabricsProxy, udisks_nvme_fabrics_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_NVME_FABRICS, udisks_nvme_fabrics_proxy_iface_init))

#endif
static void
udisks_nvme_fabrics_proxy_finalize (GObject *object)
{
  UDisksNVMeFabricsProxy *proxy = UDISKS_NVME_FABRICS_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_nvme_fabrics_proxy_parent_class)->finalize (object);
}

static void
udisks_nvme_fabrics_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_nvme_fabrics_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_nvme_fabrics_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.NVMe.Fabrics: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_nvme_fabrics_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_nvme_fabrics_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.NVMe.Fabrics", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_nvme_fabrics_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_nvme_fabrics_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_nvme_fabrics_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_NVME_FABRICS);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_NVME_FABRICS);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_nvme_fabrics_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksNVMeFabricsProxy *proxy = UDISKS_NVME_FABRICS_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_nvme_fabrics_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_nvme_fabrics_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_nvme_fabrics_proxy_get_host_nqn (UDisksNVMeFabrics *object)
{
  UDisksNVMeFabricsProxy *proxy = UDISKS_NVME_FABRICS_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "HostNQN");
  if (variant != NULL)
    {
      value = g_variant_get_bytestring (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_nvme_fabrics_proxy_get_host_id (UDisksNVMeFabrics *object)
{
  UDisksNVMeFabricsProxy *proxy = UDISKS_NVME_FABRICS_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "HostID");
  if (variant != NULL)
    {
      value = g_variant_get_bytestring (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_nvme_fabrics_proxy_get_transport (UDisksNVMeFabrics *object)
{
  UDisksNVMeFabricsProxy *proxy = UDISKS_NVME_FABRICS_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Transport");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_nvme_fabrics_proxy_get_transport_address (UDisksNVMeFabrics *object)
{
  UDisksNVMeFabricsProxy *proxy = UDISKS_NVME_FABRICS_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "TransportAddress");
  if (variant != NULL)
    {
      value = g_variant_get_bytestring (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_nvme_fabrics_proxy_init (UDisksNVMeFabricsProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_nvme_fabrics_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_NVME_FABRICS_PROXY, UDisksNVMeFabricsProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_nvme_fabrics_interface_info ());
}

static void
udisks_nvme_fabrics_proxy_class_init (UDisksNVMeFabricsProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_nvme_fabrics_proxy_finalize;
  gobject_class->get_property = udisks_nvme_fabrics_proxy_get_property;
  gobject_class->set_property = udisks_nvme_fabrics_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_nvme_fabrics_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_nvme_fabrics_proxy_g_properties_changed;

  udisks_nvme_fabrics_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksNVMeFabricsProxyPrivate));
#endif
}

static void
udisks_nvme_fabrics_proxy_iface_init (UDisksNVMeFabricsIface *iface)
{
  iface->get_host_nqn = udisks_nvme_fabrics_proxy_get_host_nqn;
  iface->get_host_id = udisks_nvme_fabrics_proxy_get_host_id;
  iface->get_transport = udisks_nvme_fabrics_proxy_get_transport;
  iface->get_transport_address = udisks_nvme_fabrics_proxy_get_transport_address;
}

/**
 * udisks_nvme_fabrics_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Fabrics.top_of_page">org.freedesktop.UDisks2.NVMe.Fabrics</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_nvme_fabrics_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_nvme_fabrics_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_nvme_fabrics_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_NVME_FABRICS_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.NVMe.Fabrics", NULL);
}

/**
 * udisks_nvme_fabrics_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_nvme_fabrics_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_nvme_fabrics_proxy_new().
 *
 * Returns: (transfer full) (type UDisksNVMeFabricsProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksNVMeFabrics *
udisks_nvme_fabrics_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_NVME_FABRICS (ret);
  else
    return NULL;
}

/**
 * udisks_nvme_fabrics_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Fabrics.top_of_page">org.freedesktop.UDisks2.NVMe.Fabrics</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_nvme_fabrics_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksNVMeFabricsProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksNVMeFabrics *
udisks_nvme_fabrics_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_NVME_FABRICS_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.NVMe.Fabrics", NULL);
  if (ret != NULL)
    return UDISKS_NVME_FABRICS (ret);
  else
    return NULL;
}


/**
 * udisks_nvme_fabrics_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_nvme_fabrics_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_nvme_fabrics_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_nvme_fabrics_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_nvme_fabrics_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_NVME_FABRICS_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.NVMe.Fabrics", NULL);
}

/**
 * udisks_nvme_fabrics_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_nvme_fabrics_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_nvme_fabrics_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksNVMeFabricsProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksNVMeFabrics *
udisks_nvme_fabrics_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_NVME_FABRICS (ret);
  else
    return NULL;
}

/**
 * udisks_nvme_fabrics_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_nvme_fabrics_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_nvme_fabrics_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksNVMeFabricsProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksNVMeFabrics *
udisks_nvme_fabrics_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_NVME_FABRICS_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.NVMe.Fabrics", NULL);
  if (ret != NULL)
    return UDISKS_NVME_FABRICS (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksNVMeFabricsSkeleton:
 *
 * The #UDisksNVMeFabricsSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksNVMeFabricsSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksNVMeFabricsSkeleton.
 */

struct _UDisksNVMeFabricsSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_nvme_fabrics_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_NVME_FABRICS);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_NVME_FABRICS);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_nvme_fabrics_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_nvme_fabrics_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_nvme_fabrics_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_nvme_fabrics_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_nvme_fabrics_skeleton_vtable =
{
  _udisks_nvme_fabrics_skeleton_handle_method_call,
  _udisks_nvme_fabrics_skeleton_handle_get_property,
  _udisks_nvme_fabrics_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_nvme_fabrics_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_nvme_fabrics_interface_info ();
}

static GDBusInterfaceVTable *
udisks_nvme_fabrics_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_nvme_fabrics_skeleton_vtable;
}

static GVariant *
udisks_nvme_fabrics_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_nvme_fabrics_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_nvme_fabrics_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_nvme_fabrics_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_nvme_fabrics_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.NVMe.Fabrics", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_nvme_fabrics_emit_changed (gpointer user_data);

static void
udisks_nvme_fabrics_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_nvme_fabrics_emit_changed (skeleton);
}

static void udisks_nvme_fabrics_skeleton_iface_init (UDisksNVMeFabricsIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksNVMeFabricsSkeleton, udisks_nvme_fabrics_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksNVMeFabricsSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_NVME_FABRICS, udisks_nvme_fabrics_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksNVMeFabricsSkeleton, udisks_nvme_fabrics_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_NVME_FABRICS, udisks_nvme_fabrics_skeleton_iface_init))

#endif
static void
udisks_nvme_fabrics_skeleton_finalize (GObject *object)
{
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (object);
  guint n;
  for (n = 0; n < 4; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_nvme_fabrics_skeleton_parent_class)->finalize (object);
}

static void
udisks_nvme_fabrics_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_nvme_fabrics_emit_changed (gpointer user_data)
{
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.NVMe.Fabrics",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_nvme_fabrics_schedule_emit_changed (UDisksNVMeFabricsSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_nvme_fabrics_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_nvme_fabrics_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_nvme_fabrics_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_nvme_fabrics_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_nvme_fabrics_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_nvme_fabrics_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_nvme_fabrics_skeleton_init (UDisksNVMeFabricsSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_nvme_fabrics_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_NVME_FABRICS_SKELETON, UDisksNVMeFabricsSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 4);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_STRING);
}

static const gchar *
udisks_nvme_fabrics_skeleton_get_host_nqn (UDisksNVMeFabrics *object)
{
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_nvme_fabrics_skeleton_get_host_id (UDisksNVMeFabrics *object)
{
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_nvme_fabrics_skeleton_get_transport (UDisksNVMeFabrics *object)
{
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_nvme_fabrics_skeleton_get_transport_address (UDisksNVMeFabrics *object)
{
  UDisksNVMeFabricsSkeleton *skeleton = UDISKS_NVME_FABRICS_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_nvme_fabrics_skeleton_class_init (UDisksNVMeFabricsSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_nvme_fabrics_skeleton_finalize;
  gobject_class->get_property = udisks_nvme_fabrics_skeleton_get_property;
  gobject_class->set_property = udisks_nvme_fabrics_skeleton_set_property;
  gobject_class->notify       = udisks_nvme_fabrics_skeleton_notify;


  udisks_nvme_fabrics_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_nvme_fabrics_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_nvme_fabrics_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_nvme_fabrics_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_nvme_fabrics_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksNVMeFabricsSkeletonPrivate));
#endif
}

static void
udisks_nvme_fabrics_skeleton_iface_init (UDisksNVMeFabricsIface *iface)
{
  iface->get_host_nqn = udisks_nvme_fabrics_skeleton_get_host_nqn;
  iface->get_host_id = udisks_nvme_fabrics_skeleton_get_host_id;
  iface->get_transport = udisks_nvme_fabrics_skeleton_get_transport;
  iface->get_transport_address = udisks_nvme_fabrics_skeleton_get_transport_address;
}

/**
 * udisks_nvme_fabrics_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Fabrics.top_of_page">org.freedesktop.UDisks2.NVMe.Fabrics</link>.
 *
 * Returns: (transfer full) (type UDisksNVMeFabricsSkeleton): The skeleton object.
 */
UDisksNVMeFabrics *
udisks_nvme_fabrics_skeleton_new (void)
{
  return UDISKS_NVME_FABRICS (g_object_new (UDISKS_TYPE_NVME_FABRICS_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Block
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksBlock
 * @title: UDisksBlock
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Block D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block.top_of_page">org.freedesktop.UDisks2.Block</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Block ---- */

static const _ExtendedGDBusArgInfo _udisks_block_method_info_add_configuration_item_IN_ARG_item =
{
  {
    -1,
    (gchar *) "item",
    (gchar *) "(sa{sv})",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_add_configuration_item_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_add_configuration_item_IN_ARG_pointers[] =
{
  &_udisks_block_method_info_add_configuration_item_IN_ARG_item.parent_struct,
  &_udisks_block_method_info_add_configuration_item_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_block_method_info_add_configuration_item =
{
  {
    -1,
    (gchar *) "AddConfigurationItem",
    (GDBusArgInfo **) &_udisks_block_method_info_add_configuration_item_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-add-configuration-item",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_remove_configuration_item_IN_ARG_item =
{
  {
    -1,
    (gchar *) "item",
    (gchar *) "(sa{sv})",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_remove_configuration_item_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_remove_configuration_item_IN_ARG_pointers[] =
{
  &_udisks_block_method_info_remove_configuration_item_IN_ARG_item.parent_struct,
  &_udisks_block_method_info_remove_configuration_item_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_block_method_info_remove_configuration_item =
{
  {
    -1,
    (gchar *) "RemoveConfigurationItem",
    (GDBusArgInfo **) &_udisks_block_method_info_remove_configuration_item_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-remove-configuration-item",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_update_configuration_item_IN_ARG_old_item =
{
  {
    -1,
    (gchar *) "old_item",
    (gchar *) "(sa{sv})",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_update_configuration_item_IN_ARG_new_item =
{
  {
    -1,
    (gchar *) "new_item",
    (gchar *) "(sa{sv})",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_update_configuration_item_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_update_configuration_item_IN_ARG_pointers[] =
{
  &_udisks_block_method_info_update_configuration_item_IN_ARG_old_item.parent_struct,
  &_udisks_block_method_info_update_configuration_item_IN_ARG_new_item.parent_struct,
  &_udisks_block_method_info_update_configuration_item_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_block_method_info_update_configuration_item =
{
  {
    -1,
    (gchar *) "UpdateConfigurationItem",
    (GDBusArgInfo **) &_udisks_block_method_info_update_configuration_item_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-update-configuration-item",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_get_secret_configuration_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_get_secret_configuration_IN_ARG_pointers[] =
{
  &_udisks_block_method_info_get_secret_configuration_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_get_secret_configuration_OUT_ARG_configuration =
{
  {
    -1,
    (gchar *) "configuration",
    (gchar *) "a(sa{sv})",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_get_secret_configuration_OUT_ARG_pointers[] =
{
  &_udisks_block_method_info_get_secret_configuration_OUT_ARG_configuration.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_block_method_info_get_secret_configuration =
{
  {
    -1,
    (gchar *) "GetSecretConfiguration",
    (GDBusArgInfo **) &_udisks_block_method_info_get_secret_configuration_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_block_method_info_get_secret_configuration_OUT_ARG_pointers,
    NULL
  },
  "handle-get-secret-configuration",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_format_IN_ARG_type =
{
  {
    -1,
    (gchar *) "type",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_format_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_format_IN_ARG_pointers[] =
{
  &_udisks_block_method_info_format_IN_ARG_type.parent_struct,
  &_udisks_block_method_info_format_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_block_method_info_format =
{
  {
    -1,
    (gchar *) "Format",
    (GDBusArgInfo **) &_udisks_block_method_info_format_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-format",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_open_for_backup_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_open_for_backup_IN_ARG_pointers[] =
{
  &_udisks_block_method_info_open_for_backup_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_open_for_backup_OUT_ARG_fd =
{
  {
    -1,
    (gchar *) "fd",
    (gchar *) "h",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_open_for_backup_OUT_ARG_pointers[] =
{
  &_udisks_block_method_info_open_for_backup_OUT_ARG_fd.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_block_method_info_open_for_backup =
{
  {
    -1,
    (gchar *) "OpenForBackup",
    (GDBusArgInfo **) &_udisks_block_method_info_open_for_backup_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_block_method_info_open_for_backup_OUT_ARG_pointers,
    NULL
  },
  "handle-open-for-backup",
  TRUE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_open_for_restore_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_open_for_restore_IN_ARG_pointers[] =
{
  &_udisks_block_method_info_open_for_restore_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_open_for_restore_OUT_ARG_fd =
{
  {
    -1,
    (gchar *) "fd",
    (gchar *) "h",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_open_for_restore_OUT_ARG_pointers[] =
{
  &_udisks_block_method_info_open_for_restore_OUT_ARG_fd.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_block_method_info_open_for_restore =
{
  {
    -1,
    (gchar *) "OpenForRestore",
    (GDBusArgInfo **) &_udisks_block_method_info_open_for_restore_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_block_method_info_open_for_restore_OUT_ARG_pointers,
    NULL
  },
  "handle-open-for-restore",
  TRUE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_open_for_benchmark_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_open_for_benchmark_IN_ARG_pointers[] =
{
  &_udisks_block_method_info_open_for_benchmark_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_open_for_benchmark_OUT_ARG_fd =
{
  {
    -1,
    (gchar *) "fd",
    (gchar *) "h",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_open_for_benchmark_OUT_ARG_pointers[] =
{
  &_udisks_block_method_info_open_for_benchmark_OUT_ARG_fd.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_block_method_info_open_for_benchmark =
{
  {
    -1,
    (gchar *) "OpenForBenchmark",
    (GDBusArgInfo **) &_udisks_block_method_info_open_for_benchmark_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_block_method_info_open_for_benchmark_OUT_ARG_pointers,
    NULL
  },
  "handle-open-for-benchmark",
  TRUE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_open_device_IN_ARG_mode =
{
  {
    -1,
    (gchar *) "mode",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_open_device_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_open_device_IN_ARG_pointers[] =
{
  &_udisks_block_method_info_open_device_IN_ARG_mode.parent_struct,
  &_udisks_block_method_info_open_device_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_open_device_OUT_ARG_fd =
{
  {
    -1,
    (gchar *) "fd",
    (gchar *) "h",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_open_device_OUT_ARG_pointers[] =
{
  &_udisks_block_method_info_open_device_OUT_ARG_fd.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_block_method_info_open_device =
{
  {
    -1,
    (gchar *) "OpenDevice",
    (GDBusArgInfo **) &_udisks_block_method_info_open_device_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_block_method_info_open_device_OUT_ARG_pointers,
    NULL
  },
  "handle-open-device",
  TRUE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_rescan_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_rescan_IN_ARG_pointers[] =
{
  &_udisks_block_method_info_rescan_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_block_method_info_rescan =
{
  {
    -1,
    (gchar *) "Rescan",
    (GDBusArgInfo **) &_udisks_block_method_info_rescan_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-rescan",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_restore_encrypted_header_IN_ARG_backup_file =
{
  {
    -1,
    (gchar *) "backup_file",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_block_method_info_restore_encrypted_header_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_block_method_info_restore_encrypted_header_IN_ARG_pointers[] =
{
  &_udisks_block_method_info_restore_encrypted_header_IN_ARG_backup_file.parent_struct,
  &_udisks_block_method_info_restore_encrypted_header_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_block_method_info_restore_encrypted_header =
{
  {
    -1,
    (gchar *) "RestoreEncryptedHeader",
    (GDBusArgInfo **) &_udisks_block_method_info_restore_encrypted_header_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-restore-encrypted-header",
  FALSE
};

static const GDBusMethodInfo * const _udisks_block_method_info_pointers[] =
{
  &_udisks_block_method_info_add_configuration_item.parent_struct,
  &_udisks_block_method_info_remove_configuration_item.parent_struct,
  &_udisks_block_method_info_update_configuration_item.parent_struct,
  &_udisks_block_method_info_get_secret_configuration.parent_struct,
  &_udisks_block_method_info_format.parent_struct,
  &_udisks_block_method_info_open_for_backup.parent_struct,
  &_udisks_block_method_info_open_for_restore.parent_struct,
  &_udisks_block_method_info_open_for_benchmark.parent_struct,
  &_udisks_block_method_info_open_device.parent_struct,
  &_udisks_block_method_info_rescan.parent_struct,
  &_udisks_block_method_info_restore_encrypted_header.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_device =
{
  {
    -1,
    (gchar *) "Device",
    (gchar *) "ay",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "device",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_preferred_device =
{
  {
    -1,
    (gchar *) "PreferredDevice",
    (gchar *) "ay",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "preferred-device",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_symlinks =
{
  {
    -1,
    (gchar *) "Symlinks",
    (gchar *) "aay",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "symlinks",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_device_number =
{
  {
    -1,
    (gchar *) "DeviceNumber",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "device-number",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_id =
{
  {
    -1,
    (gchar *) "Id",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "id",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_size =
{
  {
    -1,
    (gchar *) "Size",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "size",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_read_only =
{
  {
    -1,
    (gchar *) "ReadOnly",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "read-only",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_drive =
{
  {
    -1,
    (gchar *) "Drive",
    (gchar *) "o",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "drive",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_mdraid =
{
  {
    -1,
    (gchar *) "MDRaid",
    (gchar *) "o",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "mdraid",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_mdraid_member =
{
  {
    -1,
    (gchar *) "MDRaidMember",
    (gchar *) "o",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "mdraid-member",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_id_usage =
{
  {
    -1,
    (gchar *) "IdUsage",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "id-usage",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_id_type =
{
  {
    -1,
    (gchar *) "IdType",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "id-type",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_id_version =
{
  {
    -1,
    (gchar *) "IdVersion",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "id-version",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_id_label =
{
  {
    -1,
    (gchar *) "IdLabel",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "id-label",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_id_uuid =
{
  {
    -1,
    (gchar *) "IdUUID",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "id-uuid",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_configuration =
{
  {
    -1,
    (gchar *) "Configuration",
    (gchar *) "a(sa{sv})",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "configuration",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_crypto_backing_device =
{
  {
    -1,
    (gchar *) "CryptoBackingDevice",
    (gchar *) "o",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "crypto-backing-device",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_hint_partitionable =
{
  {
    -1,
    (gchar *) "HintPartitionable",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "hint-partitionable",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_hint_system =
{
  {
    -1,
    (gchar *) "HintSystem",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "hint-system",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_hint_ignore =
{
  {
    -1,
    (gchar *) "HintIgnore",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "hint-ignore",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_hint_auto =
{
  {
    -1,
    (gchar *) "HintAuto",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "hint-auto",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_hint_name =
{
  {
    -1,
    (gchar *) "HintName",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "hint-name",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_hint_icon_name =
{
  {
    -1,
    (gchar *) "HintIconName",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "hint-icon-name",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_hint_symbolic_icon_name =
{
  {
    -1,
    (gchar *) "HintSymbolicIconName",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "hint-symbolic-icon-name",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_block_property_info_userspace_mount_options =
{
  {
    -1,
    (gchar *) "UserspaceMountOptions",
    (gchar *) "as",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "userspace-mount-options",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_block_property_info_pointers[] =
{
  &_udisks_block_property_info_device.parent_struct,
  &_udisks_block_property_info_preferred_device.parent_struct,
  &_udisks_block_property_info_symlinks.parent_struct,
  &_udisks_block_property_info_device_number.parent_struct,
  &_udisks_block_property_info_id.parent_struct,
  &_udisks_block_property_info_size.parent_struct,
  &_udisks_block_property_info_read_only.parent_struct,
  &_udisks_block_property_info_drive.parent_struct,
  &_udisks_block_property_info_mdraid.parent_struct,
  &_udisks_block_property_info_mdraid_member.parent_struct,
  &_udisks_block_property_info_id_usage.parent_struct,
  &_udisks_block_property_info_id_type.parent_struct,
  &_udisks_block_property_info_id_version.parent_struct,
  &_udisks_block_property_info_id_label.parent_struct,
  &_udisks_block_property_info_id_uuid.parent_struct,
  &_udisks_block_property_info_configuration.parent_struct,
  &_udisks_block_property_info_crypto_backing_device.parent_struct,
  &_udisks_block_property_info_hint_partitionable.parent_struct,
  &_udisks_block_property_info_hint_system.parent_struct,
  &_udisks_block_property_info_hint_ignore.parent_struct,
  &_udisks_block_property_info_hint_auto.parent_struct,
  &_udisks_block_property_info_hint_name.parent_struct,
  &_udisks_block_property_info_hint_icon_name.parent_struct,
  &_udisks_block_property_info_hint_symbolic_icon_name.parent_struct,
  &_udisks_block_property_info_userspace_mount_options.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_block_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Block",
    (GDBusMethodInfo **) &_udisks_block_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_block_property_info_pointers,
    NULL
  },
  "block",
};


/**
 * udisks_block_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block.top_of_page">org.freedesktop.UDisks2.Block</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_block_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_block_interface_info.parent_struct;
}

/**
 * udisks_block_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksBlock interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_block_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "device");
  g_object_class_override_property (klass, property_id_begin++, "preferred-device");
  g_object_class_override_property (klass, property_id_begin++, "symlinks");
  g_object_class_override_property (klass, property_id_begin++, "device-number");
  g_object_class_override_property (klass, property_id_begin++, "id");
  g_object_class_override_property (klass, property_id_begin++, "size");
  g_object_class_override_property (klass, property_id_begin++, "read-only");
  g_object_class_override_property (klass, property_id_begin++, "drive");
  g_object_class_override_property (klass, property_id_begin++, "mdraid");
  g_object_class_override_property (klass, property_id_begin++, "mdraid-member");
  g_object_class_override_property (klass, property_id_begin++, "id-usage");
  g_object_class_override_property (klass, property_id_begin++, "id-type");
  g_object_class_override_property (klass, property_id_begin++, "id-version");
  g_object_class_override_property (klass, property_id_begin++, "id-label");
  g_object_class_override_property (klass, property_id_begin++, "id-uuid");
  g_object_class_override_property (klass, property_id_begin++, "configuration");
  g_object_class_override_property (klass, property_id_begin++, "crypto-backing-device");
  g_object_class_override_property (klass, property_id_begin++, "hint-partitionable");
  g_object_class_override_property (klass, property_id_begin++, "hint-system");
  g_object_class_override_property (klass, property_id_begin++, "hint-ignore");
  g_object_class_override_property (klass, property_id_begin++, "hint-auto");
  g_object_class_override_property (klass, property_id_begin++, "hint-name");
  g_object_class_override_property (klass, property_id_begin++, "hint-icon-name");
  g_object_class_override_property (klass, property_id_begin++, "hint-symbolic-icon-name");
  g_object_class_override_property (klass, property_id_begin++, "userspace-mount-options");
  return property_id_begin - 1;
}


inline static void
udisks_block_method_marshal_add_configuration_item (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_block_method_marshal_remove_configuration_item (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_block_method_marshal_update_configuration_item (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT_VARIANT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_block_method_marshal_get_secret_configuration (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_block_method_marshal_format (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_block_method_marshal_open_for_backup (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_block_method_marshal_open_for_restore (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_block_method_marshal_open_for_benchmark (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_block_method_marshal_open_device (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_block_method_marshal_rescan (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_block_method_marshal_restore_encrypted_header (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksBlock:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block.top_of_page">org.freedesktop.UDisks2.Block</link>.
 */

/**
 * UDisksBlockIface:
 * @parent_iface: The parent interface.
 * @handle_add_configuration_item: Handler for the #UDisksBlock::handle-add-configuration-item signal.
 * @handle_format: Handler for the #UDisksBlock::handle-format signal.
 * @handle_get_secret_configuration: Handler for the #UDisksBlock::handle-get-secret-configuration signal.
 * @handle_open_for_backup: Handler for the #UDisksBlock::handle-open-for-backup signal.
 * @handle_open_for_benchmark: Handler for the #UDisksBlock::handle-open-for-benchmark signal.
 * @handle_open_for_restore: Handler for the #UDisksBlock::handle-open-for-restore signal.
 * @handle_remove_configuration_item: Handler for the #UDisksBlock::handle-remove-configuration-item signal.
 * @handle_rescan: Handler for the #UDisksBlock::handle-rescan signal.
 * @handle_update_configuration_item: Handler for the #UDisksBlock::handle-update-configuration-item signal.
 * @get_configuration: Getter for the #UDisksBlock:configuration property.
 * @get_crypto_backing_device: Getter for the #UDisksBlock:crypto-backing-device property.
 * @get_device: Getter for the #UDisksBlock:device property.
 * @get_device_number: Getter for the #UDisksBlock:device-number property.
 * @get_drive: Getter for the #UDisksBlock:drive property.
 * @get_hint_auto: Getter for the #UDisksBlock:hint-auto property.
 * @get_hint_icon_name: Getter for the #UDisksBlock:hint-icon-name property.
 * @get_hint_ignore: Getter for the #UDisksBlock:hint-ignore property.
 * @get_hint_name: Getter for the #UDisksBlock:hint-name property.
 * @get_hint_partitionable: Getter for the #UDisksBlock:hint-partitionable property.
 * @get_hint_symbolic_icon_name: Getter for the #UDisksBlock:hint-symbolic-icon-name property.
 * @get_hint_system: Getter for the #UDisksBlock:hint-system property.
 * @get_id: Getter for the #UDisksBlock:id property.
 * @get_id_label: Getter for the #UDisksBlock:id-label property.
 * @get_id_type: Getter for the #UDisksBlock:id-type property.
 * @get_id_usage: Getter for the #UDisksBlock:id-usage property.
 * @get_id_uuid: Getter for the #UDisksBlock:id-uuid property.
 * @get_id_version: Getter for the #UDisksBlock:id-version property.
 * @get_mdraid: Getter for the #UDisksBlock:mdraid property.
 * @get_mdraid_member: Getter for the #UDisksBlock:mdraid-member property.
 * @get_preferred_device: Getter for the #UDisksBlock:preferred-device property.
 * @get_read_only: Getter for the #UDisksBlock:read-only property.
 * @get_size: Getter for the #UDisksBlock:size property.
 * @get_symlinks: Getter for the #UDisksBlock:symlinks property.
 * @get_userspace_mount_options: Getter for the #UDisksBlock:userspace-mount-options property.
 * @handle_open_device: Handler for the #UDisksBlock::handle-open-device signal.
 * @handle_restore_encrypted_header: Handler for the #UDisksBlock::handle-restore-encrypted-header signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block.top_of_page">org.freedesktop.UDisks2.Block</link>.
 */

typedef UDisksBlockIface UDisksBlockInterface;
G_DEFINE_INTERFACE (UDisksBlock, udisks_block, G_TYPE_OBJECT)

static void
udisks_block_default_init (UDisksBlockIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksBlock::handle-add-configuration-item:
   * @object: A #UDisksBlock.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_item: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.AddConfigurationItem">AddConfigurationItem()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_block_complete_add_configuration_item() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-add-configuration-item",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksBlockIface, handle_add_configuration_item),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_block_method_marshal_add_configuration_item,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT, G_TYPE_VARIANT);

  /**
   * UDisksBlock::handle-remove-configuration-item:
   * @object: A #UDisksBlock.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_item: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.RemoveConfigurationItem">RemoveConfigurationItem()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_block_complete_remove_configuration_item() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-remove-configuration-item",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksBlockIface, handle_remove_configuration_item),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_block_method_marshal_remove_configuration_item,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT, G_TYPE_VARIANT);

  /**
   * UDisksBlock::handle-update-configuration-item:
   * @object: A #UDisksBlock.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_old_item: Argument passed by remote caller.
   * @arg_new_item: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.UpdateConfigurationItem">UpdateConfigurationItem()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_block_complete_update_configuration_item() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-update-configuration-item",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksBlockIface, handle_update_configuration_item),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_block_method_marshal_update_configuration_item,
    G_TYPE_BOOLEAN,
    4,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT, G_TYPE_VARIANT, G_TYPE_VARIANT);

  /**
   * UDisksBlock::handle-get-secret-configuration:
   * @object: A #UDisksBlock.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.GetSecretConfiguration">GetSecretConfiguration()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_block_complete_get_secret_configuration() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-get-secret-configuration",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksBlockIface, handle_get_secret_configuration),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_block_method_marshal_get_secret_configuration,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksBlock::handle-format:
   * @object: A #UDisksBlock.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_type: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.Format">Format()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_block_complete_format() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-format",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksBlockIface, handle_format),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_block_method_marshal_format,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksBlock::handle-open-for-backup:
   * @object: A #UDisksBlock.
   * @invocation: A #GDBusMethodInvocation.
   * @fd_list: (nullable): A #GUnixFDList or %NULL.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenForBackup">OpenForBackup()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_block_complete_open_for_backup() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-open-for-backup",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksBlockIface, handle_open_for_backup),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_block_method_marshal_open_for_backup,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UNIX_FD_LIST, G_TYPE_VARIANT);

  /**
   * UDisksBlock::handle-open-for-restore:
   * @object: A #UDisksBlock.
   * @invocation: A #GDBusMethodInvocation.
   * @fd_list: (nullable): A #GUnixFDList or %NULL.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenForRestore">OpenForRestore()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_block_complete_open_for_restore() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-open-for-restore",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksBlockIface, handle_open_for_restore),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_block_method_marshal_open_for_restore,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UNIX_FD_LIST, G_TYPE_VARIANT);

  /**
   * UDisksBlock::handle-open-for-benchmark:
   * @object: A #UDisksBlock.
   * @invocation: A #GDBusMethodInvocation.
   * @fd_list: (nullable): A #GUnixFDList or %NULL.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenForBenchmark">OpenForBenchmark()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_block_complete_open_for_benchmark() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-open-for-benchmark",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksBlockIface, handle_open_for_benchmark),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_block_method_marshal_open_for_benchmark,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UNIX_FD_LIST, G_TYPE_VARIANT);

  /**
   * UDisksBlock::handle-open-device:
   * @object: A #UDisksBlock.
   * @invocation: A #GDBusMethodInvocation.
   * @fd_list: (nullable): A #GUnixFDList or %NULL.
   * @arg_mode: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenDevice">OpenDevice()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_block_complete_open_device() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.7.3
   */
  g_signal_new ("handle-open-device",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksBlockIface, handle_open_device),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_block_method_marshal_open_device,
    G_TYPE_BOOLEAN,
    4,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UNIX_FD_LIST, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksBlock::handle-rescan:
   * @object: A #UDisksBlock.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.Rescan">Rescan()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_block_complete_rescan() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-rescan",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksBlockIface, handle_rescan),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_block_method_marshal_rescan,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksBlock::handle-restore-encrypted-header:
   * @object: A #UDisksBlock.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_backup_file: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.RestoreEncryptedHeader">RestoreEncryptedHeader()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_block_complete_restore_encrypted_header() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.11.0
   */
  g_signal_new ("handle-restore-encrypted-header",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksBlockIface, handle_restore_encrypted_header),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_block_method_marshal_restore_encrypted_header,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksBlock:device:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Device">"Device"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("device", "Device", "Device", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:preferred-device:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.PreferredDevice">"PreferredDevice"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("preferred-device", "PreferredDevice", "PreferredDevice", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:symlinks:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Symlinks">"Symlinks"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boxed ("symlinks", "Symlinks", "Symlinks", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:device-number:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.DeviceNumber">"DeviceNumber"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("device-number", "DeviceNumber", "DeviceNumber", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:id:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Id">"Id"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("id", "Id", "Id", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Size">"Size"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("size", "Size", "Size", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:read-only:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.ReadOnly">"ReadOnly"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("read-only", "ReadOnly", "ReadOnly", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:drive:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Drive">"Drive"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("drive", "Drive", "Drive", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:mdraid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.MDRaid">"MDRaid"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("mdraid", "MDRaid", "MDRaid", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:mdraid-member:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.MDRaidMember">"MDRaidMember"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("mdraid-member", "MDRaidMember", "MDRaidMember", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:id-usage:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdUsage">"IdUsage"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("id-usage", "IdUsage", "IdUsage", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:id-type:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdType">"IdType"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("id-type", "IdType", "IdType", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:id-version:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdVersion">"IdVersion"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("id-version", "IdVersion", "IdVersion", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:id-label:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdLabel">"IdLabel"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("id-label", "IdLabel", "IdLabel", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:id-uuid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdUUID">"IdUUID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("id-uuid", "IdUUID", "IdUUID", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:configuration:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Configuration">"Configuration"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_variant ("configuration", "Configuration", "Configuration", G_VARIANT_TYPE ("a(sa{sv})"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:crypto-backing-device:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.CryptoBackingDevice">"CryptoBackingDevice"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("crypto-backing-device", "CryptoBackingDevice", "CryptoBackingDevice", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:hint-partitionable:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintPartitionable">"HintPartitionable"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("hint-partitionable", "HintPartitionable", "HintPartitionable", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:hint-system:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintSystem">"HintSystem"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("hint-system", "HintSystem", "HintSystem", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:hint-ignore:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintIgnore">"HintIgnore"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("hint-ignore", "HintIgnore", "HintIgnore", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:hint-auto:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintAuto">"HintAuto"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("hint-auto", "HintAuto", "HintAuto", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:hint-name:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintName">"HintName"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("hint-name", "HintName", "HintName", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:hint-icon-name:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintIconName">"HintIconName"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("hint-icon-name", "HintIconName", "HintIconName", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:hint-symbolic-icon-name:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintSymbolicIconName">"HintSymbolicIconName"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("hint-symbolic-icon-name", "HintSymbolicIconName", "HintSymbolicIconName", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksBlock:userspace-mount-options:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.UserspaceMountOptions">"UserspaceMountOptions"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boxed ("userspace-mount-options", "UserspaceMountOptions", "UserspaceMountOptions", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_block_get_device: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Device">"Device"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_device() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_device (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_device (object);
}

/**
 * udisks_block_dup_device: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Device">"Device"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_device (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "device", &value, NULL);
  return value;
}

/**
 * udisks_block_set_device: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Device">"Device"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_device (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "device", value, NULL);
}

/**
 * udisks_block_get_preferred_device: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.PreferredDevice">"PreferredDevice"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_preferred_device() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_preferred_device (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_preferred_device (object);
}

/**
 * udisks_block_dup_preferred_device: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.PreferredDevice">"PreferredDevice"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_preferred_device (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "preferred-device", &value, NULL);
  return value;
}

/**
 * udisks_block_set_preferred_device: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.PreferredDevice">"PreferredDevice"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_preferred_device (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "preferred-device", value, NULL);
}

/**
 * udisks_block_get_symlinks: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Symlinks">"Symlinks"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_symlinks() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *const *
udisks_block_get_symlinks (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_symlinks (object);
}

/**
 * udisks_block_dup_symlinks: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Symlinks">"Symlinks"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_strfreev().
 */
gchar **
udisks_block_dup_symlinks (UDisksBlock *object)
{
  gchar **value;
  g_object_get (G_OBJECT (object), "symlinks", &value, NULL);
  return value;
}

/**
 * udisks_block_set_symlinks: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Symlinks">"Symlinks"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_symlinks (UDisksBlock *object, const gchar *const *value)
{
  g_object_set (G_OBJECT (object), "symlinks", value, NULL);
}

/**
 * udisks_block_get_device_number: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.DeviceNumber">"DeviceNumber"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_block_get_device_number (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), 0);

  return UDISKS_BLOCK_GET_IFACE (object)->get_device_number (object);
}

/**
 * udisks_block_set_device_number: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.DeviceNumber">"DeviceNumber"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_device_number (UDisksBlock *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "device-number", value, NULL);
}

/**
 * udisks_block_get_id: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Id">"Id"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_id() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_id (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_id (object);
}

/**
 * udisks_block_dup_id: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Id">"Id"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_id (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "id", &value, NULL);
  return value;
}

/**
 * udisks_block_set_id: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Id">"Id"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_id (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "id", value, NULL);
}

/**
 * udisks_block_get_size: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Size">"Size"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_block_get_size (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), 0);

  return UDISKS_BLOCK_GET_IFACE (object)->get_size (object);
}

/**
 * udisks_block_set_size: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Size">"Size"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_size (UDisksBlock *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "size", value, NULL);
}

/**
 * udisks_block_get_read_only: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.ReadOnly">"ReadOnly"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_block_get_read_only (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), FALSE);

  return UDISKS_BLOCK_GET_IFACE (object)->get_read_only (object);
}

/**
 * udisks_block_set_read_only: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.ReadOnly">"ReadOnly"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_read_only (UDisksBlock *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "read-only", value, NULL);
}

/**
 * udisks_block_get_drive: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Drive">"Drive"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_drive() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_drive (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_drive (object);
}

/**
 * udisks_block_dup_drive: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Drive">"Drive"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_drive (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "drive", &value, NULL);
  return value;
}

/**
 * udisks_block_set_drive: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Drive">"Drive"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_drive (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "drive", value, NULL);
}

/**
 * udisks_block_get_mdraid: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.MDRaid">"MDRaid"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_mdraid() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_mdraid (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_mdraid (object);
}

/**
 * udisks_block_dup_mdraid: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.MDRaid">"MDRaid"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_mdraid (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "mdraid", &value, NULL);
  return value;
}

/**
 * udisks_block_set_mdraid: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.MDRaid">"MDRaid"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_mdraid (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "mdraid", value, NULL);
}

/**
 * udisks_block_get_mdraid_member: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.MDRaidMember">"MDRaidMember"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_mdraid_member() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_mdraid_member (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_mdraid_member (object);
}

/**
 * udisks_block_dup_mdraid_member: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.MDRaidMember">"MDRaidMember"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_mdraid_member (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "mdraid-member", &value, NULL);
  return value;
}

/**
 * udisks_block_set_mdraid_member: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.MDRaidMember">"MDRaidMember"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_mdraid_member (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "mdraid-member", value, NULL);
}

/**
 * udisks_block_get_id_usage: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdUsage">"IdUsage"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_id_usage() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_id_usage (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_id_usage (object);
}

/**
 * udisks_block_dup_id_usage: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdUsage">"IdUsage"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_id_usage (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "id-usage", &value, NULL);
  return value;
}

/**
 * udisks_block_set_id_usage: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdUsage">"IdUsage"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_id_usage (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "id-usage", value, NULL);
}

/**
 * udisks_block_get_id_type: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdType">"IdType"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_id_type() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_id_type (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_id_type (object);
}

/**
 * udisks_block_dup_id_type: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdType">"IdType"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_id_type (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "id-type", &value, NULL);
  return value;
}

/**
 * udisks_block_set_id_type: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdType">"IdType"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_id_type (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "id-type", value, NULL);
}

/**
 * udisks_block_get_id_version: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdVersion">"IdVersion"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_id_version() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_id_version (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_id_version (object);
}

/**
 * udisks_block_dup_id_version: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdVersion">"IdVersion"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_id_version (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "id-version", &value, NULL);
  return value;
}

/**
 * udisks_block_set_id_version: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdVersion">"IdVersion"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_id_version (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "id-version", value, NULL);
}

/**
 * udisks_block_get_id_label: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdLabel">"IdLabel"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_id_label() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_id_label (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_id_label (object);
}

/**
 * udisks_block_dup_id_label: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdLabel">"IdLabel"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_id_label (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "id-label", &value, NULL);
  return value;
}

/**
 * udisks_block_set_id_label: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdLabel">"IdLabel"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_id_label (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "id-label", value, NULL);
}

/**
 * udisks_block_get_id_uuid: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdUUID">"IdUUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_id_uuid() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_id_uuid (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_id_uuid (object);
}

/**
 * udisks_block_dup_id_uuid: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdUUID">"IdUUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_id_uuid (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "id-uuid", &value, NULL);
  return value;
}

/**
 * udisks_block_set_id_uuid: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.IdUUID">"IdUUID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_id_uuid (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "id-uuid", value, NULL);
}

/**
 * udisks_block_get_configuration: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Configuration">"Configuration"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_configuration() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
GVariant *
udisks_block_get_configuration (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_configuration (object);
}

/**
 * udisks_block_dup_configuration: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Configuration">"Configuration"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_variant_unref().
 */
GVariant *
udisks_block_dup_configuration (UDisksBlock *object)
{
  GVariant *value;
  g_object_get (G_OBJECT (object), "configuration", &value, NULL);
  return value;
}

/**
 * udisks_block_set_configuration: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.Configuration">"Configuration"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_configuration (UDisksBlock *object, GVariant *value)
{
  g_object_set (G_OBJECT (object), "configuration", value, NULL);
}

/**
 * udisks_block_get_crypto_backing_device: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.CryptoBackingDevice">"CryptoBackingDevice"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_crypto_backing_device() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_crypto_backing_device (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_crypto_backing_device (object);
}

/**
 * udisks_block_dup_crypto_backing_device: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.CryptoBackingDevice">"CryptoBackingDevice"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_crypto_backing_device (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "crypto-backing-device", &value, NULL);
  return value;
}

/**
 * udisks_block_set_crypto_backing_device: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.CryptoBackingDevice">"CryptoBackingDevice"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_crypto_backing_device (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "crypto-backing-device", value, NULL);
}

/**
 * udisks_block_get_hint_partitionable: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintPartitionable">"HintPartitionable"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_block_get_hint_partitionable (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), FALSE);

  return UDISKS_BLOCK_GET_IFACE (object)->get_hint_partitionable (object);
}

/**
 * udisks_block_set_hint_partitionable: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintPartitionable">"HintPartitionable"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_hint_partitionable (UDisksBlock *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "hint-partitionable", value, NULL);
}

/**
 * udisks_block_get_hint_system: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintSystem">"HintSystem"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_block_get_hint_system (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), FALSE);

  return UDISKS_BLOCK_GET_IFACE (object)->get_hint_system (object);
}

/**
 * udisks_block_set_hint_system: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintSystem">"HintSystem"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_hint_system (UDisksBlock *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "hint-system", value, NULL);
}

/**
 * udisks_block_get_hint_ignore: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintIgnore">"HintIgnore"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_block_get_hint_ignore (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), FALSE);

  return UDISKS_BLOCK_GET_IFACE (object)->get_hint_ignore (object);
}

/**
 * udisks_block_set_hint_ignore: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintIgnore">"HintIgnore"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_hint_ignore (UDisksBlock *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "hint-ignore", value, NULL);
}

/**
 * udisks_block_get_hint_auto: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintAuto">"HintAuto"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_block_get_hint_auto (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), FALSE);

  return UDISKS_BLOCK_GET_IFACE (object)->get_hint_auto (object);
}

/**
 * udisks_block_set_hint_auto: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintAuto">"HintAuto"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_hint_auto (UDisksBlock *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "hint-auto", value, NULL);
}

/**
 * udisks_block_get_hint_name: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintName">"HintName"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_hint_name() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_hint_name (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_hint_name (object);
}

/**
 * udisks_block_dup_hint_name: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintName">"HintName"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_hint_name (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "hint-name", &value, NULL);
  return value;
}

/**
 * udisks_block_set_hint_name: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintName">"HintName"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_hint_name (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "hint-name", value, NULL);
}

/**
 * udisks_block_get_hint_icon_name: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintIconName">"HintIconName"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_hint_icon_name() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_hint_icon_name (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_hint_icon_name (object);
}

/**
 * udisks_block_dup_hint_icon_name: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintIconName">"HintIconName"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_hint_icon_name (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "hint-icon-name", &value, NULL);
  return value;
}

/**
 * udisks_block_set_hint_icon_name: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintIconName">"HintIconName"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_hint_icon_name (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "hint-icon-name", value, NULL);
}

/**
 * udisks_block_get_hint_symbolic_icon_name: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintSymbolicIconName">"HintSymbolicIconName"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_hint_symbolic_icon_name() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_block_get_hint_symbolic_icon_name (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_hint_symbolic_icon_name (object);
}

/**
 * udisks_block_dup_hint_symbolic_icon_name: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintSymbolicIconName">"HintSymbolicIconName"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_block_dup_hint_symbolic_icon_name (UDisksBlock *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "hint-symbolic-icon-name", &value, NULL);
  return value;
}

/**
 * udisks_block_set_hint_symbolic_icon_name: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.HintSymbolicIconName">"HintSymbolicIconName"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_hint_symbolic_icon_name (UDisksBlock *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "hint-symbolic-icon-name", value, NULL);
}

/**
 * udisks_block_get_userspace_mount_options: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.UserspaceMountOptions">"UserspaceMountOptions"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_dup_userspace_mount_options() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *const *
udisks_block_get_userspace_mount_options (UDisksBlock *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK (object), NULL);

  return UDISKS_BLOCK_GET_IFACE (object)->get_userspace_mount_options (object);
}

/**
 * udisks_block_dup_userspace_mount_options: (skip)
 * @object: A #UDisksBlock.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.UserspaceMountOptions">"UserspaceMountOptions"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_strfreev().
 */
gchar **
udisks_block_dup_userspace_mount_options (UDisksBlock *object)
{
  gchar **value;
  g_object_get (G_OBJECT (object), "userspace-mount-options", &value, NULL);
  return value;
}

/**
 * udisks_block_set_userspace_mount_options: (skip)
 * @object: A #UDisksBlock.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block.UserspaceMountOptions">"UserspaceMountOptions"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_block_set_userspace_mount_options (UDisksBlock *object, const gchar *const *value)
{
  g_object_set (G_OBJECT (object), "userspace-mount-options", value, NULL);
}

/**
 * udisks_block_call_add_configuration_item:
 * @proxy: A #UDisksBlockProxy.
 * @arg_item: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.AddConfigurationItem">AddConfigurationItem()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_call_add_configuration_item_finish() to get the result of the operation.
 *
 * See udisks_block_call_add_configuration_item_sync() for the synchronous, blocking version of this method.
 */
void
udisks_block_call_add_configuration_item (
    UDisksBlock *proxy,
    GVariant *arg_item,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "AddConfigurationItem",
    g_variant_new ("(@(sa{sv})@a{sv})",
                   arg_item,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_block_call_add_configuration_item_finish:
 * @proxy: A #UDisksBlockProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_call_add_configuration_item().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_block_call_add_configuration_item().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_add_configuration_item_finish (
    UDisksBlock *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_add_configuration_item_sync:
 * @proxy: A #UDisksBlockProxy.
 * @arg_item: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.AddConfigurationItem">AddConfigurationItem()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_block_call_add_configuration_item() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_add_configuration_item_sync (
    UDisksBlock *proxy,
    GVariant *arg_item,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "AddConfigurationItem",
    g_variant_new ("(@(sa{sv})@a{sv})",
                   arg_item,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_remove_configuration_item:
 * @proxy: A #UDisksBlockProxy.
 * @arg_item: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.RemoveConfigurationItem">RemoveConfigurationItem()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_call_remove_configuration_item_finish() to get the result of the operation.
 *
 * See udisks_block_call_remove_configuration_item_sync() for the synchronous, blocking version of this method.
 */
void
udisks_block_call_remove_configuration_item (
    UDisksBlock *proxy,
    GVariant *arg_item,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "RemoveConfigurationItem",
    g_variant_new ("(@(sa{sv})@a{sv})",
                   arg_item,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_block_call_remove_configuration_item_finish:
 * @proxy: A #UDisksBlockProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_call_remove_configuration_item().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_block_call_remove_configuration_item().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_remove_configuration_item_finish (
    UDisksBlock *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_remove_configuration_item_sync:
 * @proxy: A #UDisksBlockProxy.
 * @arg_item: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.RemoveConfigurationItem">RemoveConfigurationItem()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_block_call_remove_configuration_item() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_remove_configuration_item_sync (
    UDisksBlock *proxy,
    GVariant *arg_item,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "RemoveConfigurationItem",
    g_variant_new ("(@(sa{sv})@a{sv})",
                   arg_item,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_update_configuration_item:
 * @proxy: A #UDisksBlockProxy.
 * @arg_old_item: Argument to pass with the method invocation.
 * @arg_new_item: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.UpdateConfigurationItem">UpdateConfigurationItem()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_call_update_configuration_item_finish() to get the result of the operation.
 *
 * See udisks_block_call_update_configuration_item_sync() for the synchronous, blocking version of this method.
 */
void
udisks_block_call_update_configuration_item (
    UDisksBlock *proxy,
    GVariant *arg_old_item,
    GVariant *arg_new_item,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "UpdateConfigurationItem",
    g_variant_new ("(@(sa{sv})@(sa{sv})@a{sv})",
                   arg_old_item,
                   arg_new_item,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_block_call_update_configuration_item_finish:
 * @proxy: A #UDisksBlockProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_call_update_configuration_item().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_block_call_update_configuration_item().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_update_configuration_item_finish (
    UDisksBlock *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_update_configuration_item_sync:
 * @proxy: A #UDisksBlockProxy.
 * @arg_old_item: Argument to pass with the method invocation.
 * @arg_new_item: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.UpdateConfigurationItem">UpdateConfigurationItem()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_block_call_update_configuration_item() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_update_configuration_item_sync (
    UDisksBlock *proxy,
    GVariant *arg_old_item,
    GVariant *arg_new_item,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "UpdateConfigurationItem",
    g_variant_new ("(@(sa{sv})@(sa{sv})@a{sv})",
                   arg_old_item,
                   arg_new_item,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_get_secret_configuration:
 * @proxy: A #UDisksBlockProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.GetSecretConfiguration">GetSecretConfiguration()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_call_get_secret_configuration_finish() to get the result of the operation.
 *
 * See udisks_block_call_get_secret_configuration_sync() for the synchronous, blocking version of this method.
 */
void
udisks_block_call_get_secret_configuration (
    UDisksBlock *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "GetSecretConfiguration",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_block_call_get_secret_configuration_finish:
 * @proxy: A #UDisksBlockProxy.
 * @out_configuration: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_call_get_secret_configuration().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_block_call_get_secret_configuration().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_get_secret_configuration_finish (
    UDisksBlock *proxy,
    GVariant ** out_configuration,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@a(sa{sv}))",
                 out_configuration);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_get_secret_configuration_sync:
 * @proxy: A #UDisksBlockProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @out_configuration: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.GetSecretConfiguration">GetSecretConfiguration()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_block_call_get_secret_configuration() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_get_secret_configuration_sync (
    UDisksBlock *proxy,
    GVariant *arg_options,
    GVariant ** out_configuration,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "GetSecretConfiguration",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@a(sa{sv}))",
                 out_configuration);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_format:
 * @proxy: A #UDisksBlockProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.Format">Format()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_call_format_finish() to get the result of the operation.
 *
 * See udisks_block_call_format_sync() for the synchronous, blocking version of this method.
 */
void
udisks_block_call_format (
    UDisksBlock *proxy,
    const gchar *arg_type,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Format",
    g_variant_new ("(s@a{sv})",
                   arg_type,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_block_call_format_finish:
 * @proxy: A #UDisksBlockProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_call_format().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_block_call_format().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_format_finish (
    UDisksBlock *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_format_sync:
 * @proxy: A #UDisksBlockProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.Format">Format()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_block_call_format() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_format_sync (
    UDisksBlock *proxy,
    const gchar *arg_type,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Format",
    g_variant_new ("(s@a{sv})",
                   arg_type,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_open_for_backup:
 * @proxy: A #UDisksBlockProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenForBackup">OpenForBackup()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_call_open_for_backup_finish() to get the result of the operation.
 *
 * See udisks_block_call_open_for_backup_sync() for the synchronous, blocking version of this method.
 */
void
udisks_block_call_open_for_backup (
    UDisksBlock *proxy,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call_with_unix_fd_list (G_DBUS_PROXY (proxy),
    "OpenForBackup",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    fd_list,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_block_call_open_for_backup_finish:
 * @proxy: A #UDisksBlockProxy.
 * @out_fd: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @out_fd_list: (out) (optional) (nullable): Return location for a #GUnixFDList or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_call_open_for_backup().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_block_call_open_for_backup().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_open_for_backup_finish (
    UDisksBlock *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_with_unix_fd_list_finish (G_DBUS_PROXY (proxy), out_fd_list, res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@h)",
                 out_fd);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_open_for_backup_sync:
 * @proxy: A #UDisksBlockProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @out_fd: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @out_fd_list: (out) (optional) (nullable): Return location for a #GUnixFDList or %NULL.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenForBackup">OpenForBackup()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_block_call_open_for_backup() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_open_for_backup_sync (
    UDisksBlock *proxy,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_with_unix_fd_list_sync (G_DBUS_PROXY (proxy),
    "OpenForBackup",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    fd_list,
    out_fd_list,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@h)",
                 out_fd);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_open_for_restore:
 * @proxy: A #UDisksBlockProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenForRestore">OpenForRestore()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_call_open_for_restore_finish() to get the result of the operation.
 *
 * See udisks_block_call_open_for_restore_sync() for the synchronous, blocking version of this method.
 */
void
udisks_block_call_open_for_restore (
    UDisksBlock *proxy,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call_with_unix_fd_list (G_DBUS_PROXY (proxy),
    "OpenForRestore",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    fd_list,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_block_call_open_for_restore_finish:
 * @proxy: A #UDisksBlockProxy.
 * @out_fd: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @out_fd_list: (out) (optional) (nullable): Return location for a #GUnixFDList or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_call_open_for_restore().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_block_call_open_for_restore().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_open_for_restore_finish (
    UDisksBlock *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_with_unix_fd_list_finish (G_DBUS_PROXY (proxy), out_fd_list, res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@h)",
                 out_fd);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_open_for_restore_sync:
 * @proxy: A #UDisksBlockProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @out_fd: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @out_fd_list: (out) (optional) (nullable): Return location for a #GUnixFDList or %NULL.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenForRestore">OpenForRestore()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_block_call_open_for_restore() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_open_for_restore_sync (
    UDisksBlock *proxy,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_with_unix_fd_list_sync (G_DBUS_PROXY (proxy),
    "OpenForRestore",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    fd_list,
    out_fd_list,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@h)",
                 out_fd);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_open_for_benchmark:
 * @proxy: A #UDisksBlockProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenForBenchmark">OpenForBenchmark()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_call_open_for_benchmark_finish() to get the result of the operation.
 *
 * See udisks_block_call_open_for_benchmark_sync() for the synchronous, blocking version of this method.
 */
void
udisks_block_call_open_for_benchmark (
    UDisksBlock *proxy,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call_with_unix_fd_list (G_DBUS_PROXY (proxy),
    "OpenForBenchmark",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    fd_list,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_block_call_open_for_benchmark_finish:
 * @proxy: A #UDisksBlockProxy.
 * @out_fd: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @out_fd_list: (out) (optional) (nullable): Return location for a #GUnixFDList or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_call_open_for_benchmark().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_block_call_open_for_benchmark().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_open_for_benchmark_finish (
    UDisksBlock *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_with_unix_fd_list_finish (G_DBUS_PROXY (proxy), out_fd_list, res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@h)",
                 out_fd);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_open_for_benchmark_sync:
 * @proxy: A #UDisksBlockProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @out_fd: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @out_fd_list: (out) (optional) (nullable): Return location for a #GUnixFDList or %NULL.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenForBenchmark">OpenForBenchmark()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_block_call_open_for_benchmark() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_open_for_benchmark_sync (
    UDisksBlock *proxy,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_with_unix_fd_list_sync (G_DBUS_PROXY (proxy),
    "OpenForBenchmark",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    fd_list,
    out_fd_list,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@h)",
                 out_fd);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_open_device:
 * @proxy: A #UDisksBlockProxy.
 * @arg_mode: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenDevice">OpenDevice()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_call_open_device_finish() to get the result of the operation.
 *
 * See udisks_block_call_open_device_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.7.3
 */
void
udisks_block_call_open_device (
    UDisksBlock *proxy,
    const gchar *arg_mode,
    GVariant *arg_options,
    GUnixFDList *fd_list,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call_with_unix_fd_list (G_DBUS_PROXY (proxy),
    "OpenDevice",
    g_variant_new ("(s@a{sv})",
                   arg_mode,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    fd_list,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_block_call_open_device_finish:
 * @proxy: A #UDisksBlockProxy.
 * @out_fd: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @out_fd_list: (out) (optional) (nullable): Return location for a #GUnixFDList or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_call_open_device().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_block_call_open_device().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.3
 */
gboolean
udisks_block_call_open_device_finish (
    UDisksBlock *proxy,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_with_unix_fd_list_finish (G_DBUS_PROXY (proxy), out_fd_list, res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@h)",
                 out_fd);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_open_device_sync:
 * @proxy: A #UDisksBlockProxy.
 * @arg_mode: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @out_fd: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @out_fd_list: (out) (optional) (nullable): Return location for a #GUnixFDList or %NULL.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenDevice">OpenDevice()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_block_call_open_device() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.3
 */
gboolean
udisks_block_call_open_device_sync (
    UDisksBlock *proxy,
    const gchar *arg_mode,
    GVariant *arg_options,
    GUnixFDList  *fd_list,
    GVariant ** out_fd,
    GUnixFDList **out_fd_list,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_with_unix_fd_list_sync (G_DBUS_PROXY (proxy),
    "OpenDevice",
    g_variant_new ("(s@a{sv})",
                   arg_mode,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    fd_list,
    out_fd_list,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@h)",
                 out_fd);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_rescan:
 * @proxy: A #UDisksBlockProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.Rescan">Rescan()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_call_rescan_finish() to get the result of the operation.
 *
 * See udisks_block_call_rescan_sync() for the synchronous, blocking version of this method.
 */
void
udisks_block_call_rescan (
    UDisksBlock *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Rescan",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_block_call_rescan_finish:
 * @proxy: A #UDisksBlockProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_call_rescan().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_block_call_rescan().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_rescan_finish (
    UDisksBlock *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_rescan_sync:
 * @proxy: A #UDisksBlockProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.Rescan">Rescan()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_block_call_rescan() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_block_call_rescan_sync (
    UDisksBlock *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Rescan",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_restore_encrypted_header:
 * @proxy: A #UDisksBlockProxy.
 * @arg_backup_file: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.RestoreEncryptedHeader">RestoreEncryptedHeader()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_call_restore_encrypted_header_finish() to get the result of the operation.
 *
 * See udisks_block_call_restore_encrypted_header_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.11.0
 */
void
udisks_block_call_restore_encrypted_header (
    UDisksBlock *proxy,
    const gchar *arg_backup_file,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "RestoreEncryptedHeader",
    g_variant_new ("(s@a{sv})",
                   arg_backup_file,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_block_call_restore_encrypted_header_finish:
 * @proxy: A #UDisksBlockProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_call_restore_encrypted_header().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_block_call_restore_encrypted_header().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11.0
 */
gboolean
udisks_block_call_restore_encrypted_header_finish (
    UDisksBlock *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_call_restore_encrypted_header_sync:
 * @proxy: A #UDisksBlockProxy.
 * @arg_backup_file: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.RestoreEncryptedHeader">RestoreEncryptedHeader()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_block_call_restore_encrypted_header() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11.0
 */
gboolean
udisks_block_call_restore_encrypted_header_sync (
    UDisksBlock *proxy,
    const gchar *arg_backup_file,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "RestoreEncryptedHeader",
    g_variant_new ("(s@a{sv})",
                   arg_backup_file,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_block_complete_add_configuration_item:
 * @object: A #UDisksBlock.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.AddConfigurationItem">AddConfigurationItem()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_block_complete_add_configuration_item (
    UDisksBlock *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_block_complete_remove_configuration_item:
 * @object: A #UDisksBlock.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.RemoveConfigurationItem">RemoveConfigurationItem()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_block_complete_remove_configuration_item (
    UDisksBlock *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_block_complete_update_configuration_item:
 * @object: A #UDisksBlock.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.UpdateConfigurationItem">UpdateConfigurationItem()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_block_complete_update_configuration_item (
    UDisksBlock *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_block_complete_get_secret_configuration:
 * @object: A #UDisksBlock.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @configuration: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.GetSecretConfiguration">GetSecretConfiguration()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_block_complete_get_secret_configuration (
    UDisksBlock *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GVariant *configuration)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(@a(sa{sv}))",
                   configuration));
}

/**
 * udisks_block_complete_format:
 * @object: A #UDisksBlock.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.Format">Format()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_block_complete_format (
    UDisksBlock *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_block_complete_open_for_backup:
 * @object: A #UDisksBlock.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @fd: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenForBackup">OpenForBackup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_block_complete_open_for_backup (
    UDisksBlock *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd)
{
  g_dbus_method_invocation_return_value_with_unix_fd_list (invocation,
    g_variant_new ("(@h)",
                   fd),
    fd_list);
}

/**
 * udisks_block_complete_open_for_restore:
 * @object: A #UDisksBlock.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @fd: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenForRestore">OpenForRestore()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_block_complete_open_for_restore (
    UDisksBlock *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd)
{
  g_dbus_method_invocation_return_value_with_unix_fd_list (invocation,
    g_variant_new ("(@h)",
                   fd),
    fd_list);
}

/**
 * udisks_block_complete_open_for_benchmark:
 * @object: A #UDisksBlock.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @fd: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenForBenchmark">OpenForBenchmark()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_block_complete_open_for_benchmark (
    UDisksBlock *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd)
{
  g_dbus_method_invocation_return_value_with_unix_fd_list (invocation,
    g_variant_new ("(@h)",
                   fd),
    fd_list);
}

/**
 * udisks_block_complete_open_device:
 * @object: A #UDisksBlock.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @fd_list: (nullable): A #GUnixFDList or %NULL.
 * @fd: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.OpenDevice">OpenDevice()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.7.3
 */
void
udisks_block_complete_open_device (
    UDisksBlock *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GUnixFDList *fd_list,
    GVariant *fd)
{
  g_dbus_method_invocation_return_value_with_unix_fd_list (invocation,
    g_variant_new ("(@h)",
                   fd),
    fd_list);
}

/**
 * udisks_block_complete_rescan:
 * @object: A #UDisksBlock.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.Rescan">Rescan()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_block_complete_rescan (
    UDisksBlock *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_block_complete_restore_encrypted_header:
 * @object: A #UDisksBlock.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Block.RestoreEncryptedHeader">RestoreEncryptedHeader()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.11.0
 */
void
udisks_block_complete_restore_encrypted_header (
    UDisksBlock *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksBlockProxy:
 *
 * The #UDisksBlockProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksBlockProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksBlockProxy.
 */

struct _UDisksBlockProxyPrivate
{
  GData *qdata;
};

static void udisks_block_proxy_iface_init (UDisksBlockIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksBlockProxy, udisks_block_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksBlockProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_BLOCK, udisks_block_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksBlockProxy, udisks_block_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_BLOCK, udisks_block_proxy_iface_init))

#endif
static void
udisks_block_proxy_finalize (GObject *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_block_proxy_parent_class)->finalize (object);
}

static void
udisks_block_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 25);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_block_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_block_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.Block: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_block_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 25);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_block_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.Block", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_block_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_block_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_block_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_BLOCK);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_BLOCK);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_block_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_block_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_block_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_block_proxy_get_device (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Device");
  if (variant != NULL)
    {
      value = g_variant_get_bytestring (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_block_proxy_get_preferred_device (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "PreferredDevice");
  if (variant != NULL)
    {
      value = g_variant_get_bytestring (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *const *
udisks_block_proxy_get_symlinks (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *const *value = NULL;
  value = g_datalist_get_data (&proxy->priv->qdata, "Symlinks");
  if (value != NULL)
    return value;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Symlinks");
  if (variant != NULL)
    {
      value = g_variant_get_bytestring_array (variant, NULL);
      g_datalist_set_data_full (&proxy->priv->qdata, "Symlinks", (gpointer) value, g_free);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_block_proxy_get_device_number (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "DeviceNumber");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_block_proxy_get_id (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Id");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_block_proxy_get_size (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Size");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_block_proxy_get_read_only (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ReadOnly");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_block_proxy_get_drive (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Drive");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_block_proxy_get_mdraid (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "MDRaid");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_block_proxy_get_mdraid_member (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "MDRaidMember");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_block_proxy_get_id_usage (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "IdUsage");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_block_proxy_get_id_type (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "IdType");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_block_proxy_get_id_version (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "IdVersion");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_block_proxy_get_id_label (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "IdLabel");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_block_proxy_get_id_uuid (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "IdUUID");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static GVariant *
udisks_block_proxy_get_configuration (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  GVariant *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Configuration");
  value = variant;
  if (variant != NULL)
    g_variant_unref (variant);
  return value;
}

static const gchar *
udisks_block_proxy_get_crypto_backing_device (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "CryptoBackingDevice");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_block_proxy_get_hint_partitionable (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "HintPartitionable");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_block_proxy_get_hint_system (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "HintSystem");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_block_proxy_get_hint_ignore (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "HintIgnore");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_block_proxy_get_hint_auto (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "HintAuto");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_block_proxy_get_hint_name (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "HintName");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_block_proxy_get_hint_icon_name (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "HintIconName");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_block_proxy_get_hint_symbolic_icon_name (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "HintSymbolicIconName");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *const *
udisks_block_proxy_get_userspace_mount_options (UDisksBlock *object)
{
  UDisksBlockProxy *proxy = UDISKS_BLOCK_PROXY (object);
  GVariant *variant;
  const gchar *const *value = NULL;
  value = g_datalist_get_data (&proxy->priv->qdata, "UserspaceMountOptions");
  if (value != NULL)
    return value;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "UserspaceMountOptions");
  if (variant != NULL)
    {
      value = g_variant_get_strv (variant, NULL);
      g_datalist_set_data_full (&proxy->priv->qdata, "UserspaceMountOptions", (gpointer) value, g_free);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_block_proxy_init (UDisksBlockProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_block_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_BLOCK_PROXY, UDisksBlockProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_block_interface_info ());
}

static void
udisks_block_proxy_class_init (UDisksBlockProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_block_proxy_finalize;
  gobject_class->get_property = udisks_block_proxy_get_property;
  gobject_class->set_property = udisks_block_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_block_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_block_proxy_g_properties_changed;

  udisks_block_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksBlockProxyPrivate));
#endif
}

static void
udisks_block_proxy_iface_init (UDisksBlockIface *iface)
{
  iface->get_device = udisks_block_proxy_get_device;
  iface->get_preferred_device = udisks_block_proxy_get_preferred_device;
  iface->get_symlinks = udisks_block_proxy_get_symlinks;
  iface->get_device_number = udisks_block_proxy_get_device_number;
  iface->get_id = udisks_block_proxy_get_id;
  iface->get_size = udisks_block_proxy_get_size;
  iface->get_read_only = udisks_block_proxy_get_read_only;
  iface->get_drive = udisks_block_proxy_get_drive;
  iface->get_mdraid = udisks_block_proxy_get_mdraid;
  iface->get_mdraid_member = udisks_block_proxy_get_mdraid_member;
  iface->get_id_usage = udisks_block_proxy_get_id_usage;
  iface->get_id_type = udisks_block_proxy_get_id_type;
  iface->get_id_version = udisks_block_proxy_get_id_version;
  iface->get_id_label = udisks_block_proxy_get_id_label;
  iface->get_id_uuid = udisks_block_proxy_get_id_uuid;
  iface->get_configuration = udisks_block_proxy_get_configuration;
  iface->get_crypto_backing_device = udisks_block_proxy_get_crypto_backing_device;
  iface->get_hint_partitionable = udisks_block_proxy_get_hint_partitionable;
  iface->get_hint_system = udisks_block_proxy_get_hint_system;
  iface->get_hint_ignore = udisks_block_proxy_get_hint_ignore;
  iface->get_hint_auto = udisks_block_proxy_get_hint_auto;
  iface->get_hint_name = udisks_block_proxy_get_hint_name;
  iface->get_hint_icon_name = udisks_block_proxy_get_hint_icon_name;
  iface->get_hint_symbolic_icon_name = udisks_block_proxy_get_hint_symbolic_icon_name;
  iface->get_userspace_mount_options = udisks_block_proxy_get_userspace_mount_options;
}

/**
 * udisks_block_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block.top_of_page">org.freedesktop.UDisks2.Block</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_block_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_block_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_BLOCK_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Block", NULL);
}

/**
 * udisks_block_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_block_proxy_new().
 *
 * Returns: (transfer full) (type UDisksBlockProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksBlock *
udisks_block_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_BLOCK (ret);
  else
    return NULL;
}

/**
 * udisks_block_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block.top_of_page">org.freedesktop.UDisks2.Block</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_block_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksBlockProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksBlock *
udisks_block_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_BLOCK_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Block", NULL);
  if (ret != NULL)
    return UDISKS_BLOCK (ret);
  else
    return NULL;
}


/**
 * udisks_block_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_block_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_block_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_block_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_BLOCK_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Block", NULL);
}

/**
 * udisks_block_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_block_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksBlockProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksBlock *
udisks_block_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_BLOCK (ret);
  else
    return NULL;
}

/**
 * udisks_block_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_block_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_block_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksBlockProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksBlock *
udisks_block_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_BLOCK_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Block", NULL);
  if (ret != NULL)
    return UDISKS_BLOCK (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksBlockSkeleton:
 *
 * The #UDisksBlockSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksBlockSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksBlockSkeleton.
 */

struct _UDisksBlockSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_block_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_BLOCK);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_BLOCK);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_block_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_block_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_block_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_block_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_block_skeleton_vtable =
{
  _udisks_block_skeleton_handle_method_call,
  _udisks_block_skeleton_handle_get_property,
  _udisks_block_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_block_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_block_interface_info ();
}

static GDBusInterfaceVTable *
udisks_block_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_block_skeleton_vtable;
}

static GVariant *
udisks_block_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_block_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_block_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_block_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_block_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Block", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_block_emit_changed (gpointer user_data);

static void
udisks_block_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_block_emit_changed (skeleton);
}

static void udisks_block_skeleton_iface_init (UDisksBlockIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksBlockSkeleton, udisks_block_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksBlockSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_BLOCK, udisks_block_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksBlockSkeleton, udisks_block_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_BLOCK, udisks_block_skeleton_iface_init))

#endif
static void
udisks_block_skeleton_finalize (GObject *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  guint n;
  for (n = 0; n < 25; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_block_skeleton_parent_class)->finalize (object);
}

static void
udisks_block_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 25);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_block_emit_changed (gpointer user_data)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.Block",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_block_schedule_emit_changed (UDisksBlockSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_block_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_block_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_block_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_block_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 25);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_block_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_block_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_block_skeleton_init (UDisksBlockSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_block_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_BLOCK_SKELETON, UDisksBlockSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 25);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_STRV);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[4], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[5], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[6], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[7], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[8], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[9], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[10], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[11], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[12], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[13], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[14], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[15], G_TYPE_VARIANT);
  g_value_init (&skeleton->priv->properties[16], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[17], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[18], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[19], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[20], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[21], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[22], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[23], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[24], G_TYPE_STRV);
}

static const gchar *
udisks_block_skeleton_get_device (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_preferred_device (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *const *
udisks_block_skeleton_get_symlinks (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *const *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boxed (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_block_skeleton_get_device_number (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_id (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[4]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_block_skeleton_get_size (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[5]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_block_skeleton_get_read_only (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[6]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_drive (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[7]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_mdraid (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[8]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_mdraid_member (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[9]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_id_usage (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[10]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_id_type (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[11]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_id_version (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[12]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_id_label (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[13]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_id_uuid (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[14]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static GVariant *
udisks_block_skeleton_get_configuration (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  GVariant *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_variant (&(skeleton->priv->properties[15]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_crypto_backing_device (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[16]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_block_skeleton_get_hint_partitionable (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[17]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_block_skeleton_get_hint_system (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[18]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_block_skeleton_get_hint_ignore (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[19]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_block_skeleton_get_hint_auto (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[20]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_hint_name (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[21]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_hint_icon_name (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[22]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_block_skeleton_get_hint_symbolic_icon_name (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[23]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *const *
udisks_block_skeleton_get_userspace_mount_options (UDisksBlock *object)
{
  UDisksBlockSkeleton *skeleton = UDISKS_BLOCK_SKELETON (object);
  const gchar *const *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boxed (&(skeleton->priv->properties[24]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_block_skeleton_class_init (UDisksBlockSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_block_skeleton_finalize;
  gobject_class->get_property = udisks_block_skeleton_get_property;
  gobject_class->set_property = udisks_block_skeleton_set_property;
  gobject_class->notify       = udisks_block_skeleton_notify;


  udisks_block_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_block_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_block_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_block_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_block_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksBlockSkeletonPrivate));
#endif
}

static void
udisks_block_skeleton_iface_init (UDisksBlockIface *iface)
{
  iface->get_device = udisks_block_skeleton_get_device;
  iface->get_preferred_device = udisks_block_skeleton_get_preferred_device;
  iface->get_symlinks = udisks_block_skeleton_get_symlinks;
  iface->get_device_number = udisks_block_skeleton_get_device_number;
  iface->get_id = udisks_block_skeleton_get_id;
  iface->get_size = udisks_block_skeleton_get_size;
  iface->get_read_only = udisks_block_skeleton_get_read_only;
  iface->get_drive = udisks_block_skeleton_get_drive;
  iface->get_mdraid = udisks_block_skeleton_get_mdraid;
  iface->get_mdraid_member = udisks_block_skeleton_get_mdraid_member;
  iface->get_id_usage = udisks_block_skeleton_get_id_usage;
  iface->get_id_type = udisks_block_skeleton_get_id_type;
  iface->get_id_version = udisks_block_skeleton_get_id_version;
  iface->get_id_label = udisks_block_skeleton_get_id_label;
  iface->get_id_uuid = udisks_block_skeleton_get_id_uuid;
  iface->get_configuration = udisks_block_skeleton_get_configuration;
  iface->get_crypto_backing_device = udisks_block_skeleton_get_crypto_backing_device;
  iface->get_hint_partitionable = udisks_block_skeleton_get_hint_partitionable;
  iface->get_hint_system = udisks_block_skeleton_get_hint_system;
  iface->get_hint_ignore = udisks_block_skeleton_get_hint_ignore;
  iface->get_hint_auto = udisks_block_skeleton_get_hint_auto;
  iface->get_hint_name = udisks_block_skeleton_get_hint_name;
  iface->get_hint_icon_name = udisks_block_skeleton_get_hint_icon_name;
  iface->get_hint_symbolic_icon_name = udisks_block_skeleton_get_hint_symbolic_icon_name;
  iface->get_userspace_mount_options = udisks_block_skeleton_get_userspace_mount_options;
}

/**
 * udisks_block_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block.top_of_page">org.freedesktop.UDisks2.Block</link>.
 *
 * Returns: (transfer full) (type UDisksBlockSkeleton): The skeleton object.
 */
UDisksBlock *
udisks_block_skeleton_new (void)
{
  return UDISKS_BLOCK (g_object_new (UDISKS_TYPE_BLOCK_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.PartitionTable
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksPartitionTable
 * @title: UDisksPartitionTable
 * @short_description: Generated C code for the org.freedesktop.UDisks2.PartitionTable D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-PartitionTable.top_of_page">org.freedesktop.UDisks2.PartitionTable</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.PartitionTable ---- */

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_IN_ARG_offset =
{
  {
    -1,
    (gchar *) "offset",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_IN_ARG_size =
{
  {
    -1,
    (gchar *) "size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_IN_ARG_type =
{
  {
    -1,
    (gchar *) "type",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_IN_ARG_name =
{
  {
    -1,
    (gchar *) "name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_partition_table_method_info_create_partition_IN_ARG_pointers[] =
{
  &_udisks_partition_table_method_info_create_partition_IN_ARG_offset.parent_struct,
  &_udisks_partition_table_method_info_create_partition_IN_ARG_size.parent_struct,
  &_udisks_partition_table_method_info_create_partition_IN_ARG_type.parent_struct,
  &_udisks_partition_table_method_info_create_partition_IN_ARG_name.parent_struct,
  &_udisks_partition_table_method_info_create_partition_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_OUT_ARG_created_partition =
{
  {
    -1,
    (gchar *) "created_partition",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_partition_table_method_info_create_partition_OUT_ARG_pointers[] =
{
  &_udisks_partition_table_method_info_create_partition_OUT_ARG_created_partition.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_partition_table_method_info_create_partition =
{
  {
    -1,
    (gchar *) "CreatePartition",
    (GDBusArgInfo **) &_udisks_partition_table_method_info_create_partition_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_partition_table_method_info_create_partition_OUT_ARG_pointers,
    NULL
  },
  "handle-create-partition",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_and_format_IN_ARG_offset =
{
  {
    -1,
    (gchar *) "offset",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_and_format_IN_ARG_size =
{
  {
    -1,
    (gchar *) "size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_and_format_IN_ARG_type =
{
  {
    -1,
    (gchar *) "type",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_and_format_IN_ARG_name =
{
  {
    -1,
    (gchar *) "name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_and_format_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_and_format_IN_ARG_format_type =
{
  {
    -1,
    (gchar *) "format_type",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_and_format_IN_ARG_format_options =
{
  {
    -1,
    (gchar *) "format_options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_partition_table_method_info_create_partition_and_format_IN_ARG_pointers[] =
{
  &_udisks_partition_table_method_info_create_partition_and_format_IN_ARG_offset.parent_struct,
  &_udisks_partition_table_method_info_create_partition_and_format_IN_ARG_size.parent_struct,
  &_udisks_partition_table_method_info_create_partition_and_format_IN_ARG_type.parent_struct,
  &_udisks_partition_table_method_info_create_partition_and_format_IN_ARG_name.parent_struct,
  &_udisks_partition_table_method_info_create_partition_and_format_IN_ARG_options.parent_struct,
  &_udisks_partition_table_method_info_create_partition_and_format_IN_ARG_format_type.parent_struct,
  &_udisks_partition_table_method_info_create_partition_and_format_IN_ARG_format_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_partition_table_method_info_create_partition_and_format_OUT_ARG_created_partition =
{
  {
    -1,
    (gchar *) "created_partition",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_partition_table_method_info_create_partition_and_format_OUT_ARG_pointers[] =
{
  &_udisks_partition_table_method_info_create_partition_and_format_OUT_ARG_created_partition.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_partition_table_method_info_create_partition_and_format =
{
  {
    -1,
    (gchar *) "CreatePartitionAndFormat",
    (GDBusArgInfo **) &_udisks_partition_table_method_info_create_partition_and_format_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_partition_table_method_info_create_partition_and_format_OUT_ARG_pointers,
    NULL
  },
  "handle-create-partition-and-format",
  FALSE
};

static const GDBusMethodInfo * const _udisks_partition_table_method_info_pointers[] =
{
  &_udisks_partition_table_method_info_create_partition.parent_struct,
  &_udisks_partition_table_method_info_create_partition_and_format.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_partition_table_property_info_partitions =
{
  {
    -1,
    (gchar *) "Partitions",
    (gchar *) "ao",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "partitions",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_partition_table_property_info_type_ =
{
  {
    -1,
    (gchar *) "Type",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "type",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_partition_table_property_info_pointers[] =
{
  &_udisks_partition_table_property_info_partitions.parent_struct,
  &_udisks_partition_table_property_info_type_.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_partition_table_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.PartitionTable",
    (GDBusMethodInfo **) &_udisks_partition_table_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_partition_table_property_info_pointers,
    NULL
  },
  "partition-table",
};


/**
 * udisks_partition_table_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-PartitionTable.top_of_page">org.freedesktop.UDisks2.PartitionTable</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_partition_table_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_partition_table_interface_info.parent_struct;
}

/**
 * udisks_partition_table_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksPartitionTable interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_partition_table_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "partitions");
  g_object_class_override_property (klass, property_id_begin++, "type");
  return property_id_begin - 1;
}


inline static void
udisks_partition_table_method_marshal_create_partition (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT64_UINT64_STRING_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_partition_table_method_marshal_create_partition_and_format (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT64_UINT64_STRING_STRING_VARIANT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksPartitionTable:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PartitionTable.top_of_page">org.freedesktop.UDisks2.PartitionTable</link>.
 */

/**
 * UDisksPartitionTableIface:
 * @parent_iface: The parent interface.
 * @handle_create_partition: Handler for the #UDisksPartitionTable::handle-create-partition signal.
 * @handle_create_partition_and_format: Handler for the #UDisksPartitionTable::handle-create-partition-and-format signal.
 * @get_partitions: Getter for the #UDisksPartitionTable:partitions property.
 * @get_type_: Getter for the #UDisksPartitionTable:type property.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PartitionTable.top_of_page">org.freedesktop.UDisks2.PartitionTable</link>.
 */

typedef UDisksPartitionTableIface UDisksPartitionTableInterface;
G_DEFINE_INTERFACE (UDisksPartitionTable, udisks_partition_table, G_TYPE_OBJECT)

static void
udisks_partition_table_default_init (UDisksPartitionTableIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksPartitionTable::handle-create-partition:
   * @object: A #UDisksPartitionTable.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_offset: Argument passed by remote caller.
   * @arg_size: Argument passed by remote caller.
   * @arg_type: Argument passed by remote caller.
   * @arg_name: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-PartitionTable.CreatePartition">CreatePartition()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_partition_table_complete_create_partition() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-create-partition",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksPartitionTableIface, handle_create_partition),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_partition_table_method_marshal_create_partition,
    G_TYPE_BOOLEAN,
    6,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksPartitionTable::handle-create-partition-and-format:
   * @object: A #UDisksPartitionTable.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_offset: Argument passed by remote caller.
   * @arg_size: Argument passed by remote caller.
   * @arg_type: Argument passed by remote caller.
   * @arg_name: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   * @arg_format_type: Argument passed by remote caller.
   * @arg_format_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-PartitionTable.CreatePartitionAndFormat">CreatePartitionAndFormat()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_partition_table_complete_create_partition_and_format() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-create-partition-and-format",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksPartitionTableIface, handle_create_partition_and_format),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_partition_table_method_marshal_create_partition_and_format,
    G_TYPE_BOOLEAN,
    8,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_VARIANT, G_TYPE_STRING, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksPartitionTable:partitions:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-PartitionTable.Partitions">"Partitions"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boxed ("partitions", "Partitions", "Partitions", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksPartitionTable:type:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-PartitionTable.Type">"Type"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("type", "Type", "Type", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_partition_table_get_partitions: (skip)
 * @object: A #UDisksPartitionTable.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-PartitionTable.Partitions">"Partitions"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_partition_table_dup_partitions() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *const *
udisks_partition_table_get_partitions (UDisksPartitionTable *object)
{
  g_return_val_if_fail (UDISKS_IS_PARTITION_TABLE (object), NULL);

  return UDISKS_PARTITION_TABLE_GET_IFACE (object)->get_partitions (object);
}

/**
 * udisks_partition_table_dup_partitions: (skip)
 * @object: A #UDisksPartitionTable.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-PartitionTable.Partitions">"Partitions"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_strfreev().
 */
gchar **
udisks_partition_table_dup_partitions (UDisksPartitionTable *object)
{
  gchar **value;
  g_object_get (G_OBJECT (object), "partitions", &value, NULL);
  return value;
}

/**
 * udisks_partition_table_set_partitions: (skip)
 * @object: A #UDisksPartitionTable.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-PartitionTable.Partitions">"Partitions"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_partition_table_set_partitions (UDisksPartitionTable *object, const gchar *const *value)
{
  g_object_set (G_OBJECT (object), "partitions", value, NULL);
}

/**
 * udisks_partition_table_get_type_: (skip)
 * @object: A #UDisksPartitionTable.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-PartitionTable.Type">"Type"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_partition_table_dup_type_() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_partition_table_get_type_ (UDisksPartitionTable *object)
{
  g_return_val_if_fail (UDISKS_IS_PARTITION_TABLE (object), NULL);

  return UDISKS_PARTITION_TABLE_GET_IFACE (object)->get_type_ (object);
}

/**
 * udisks_partition_table_dup_type_: (skip)
 * @object: A #UDisksPartitionTable.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-PartitionTable.Type">"Type"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_partition_table_dup_type_ (UDisksPartitionTable *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "type", &value, NULL);
  return value;
}

/**
 * udisks_partition_table_set_type_: (skip)
 * @object: A #UDisksPartitionTable.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-PartitionTable.Type">"Type"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_partition_table_set_type_ (UDisksPartitionTable *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "type", value, NULL);
}

/**
 * udisks_partition_table_call_create_partition:
 * @proxy: A #UDisksPartitionTableProxy.
 * @arg_offset: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_type: Argument to pass with the method invocation.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-PartitionTable.CreatePartition">CreatePartition()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_partition_table_call_create_partition_finish() to get the result of the operation.
 *
 * See udisks_partition_table_call_create_partition_sync() for the synchronous, blocking version of this method.
 */
void
udisks_partition_table_call_create_partition (
    UDisksPartitionTable *proxy,
    guint64 arg_offset,
    guint64 arg_size,
    const gchar *arg_type,
    const gchar *arg_name,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CreatePartition",
    g_variant_new ("(ttss@a{sv})",
                   arg_offset,
                   arg_size,
                   arg_type,
                   arg_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_partition_table_call_create_partition_finish:
 * @proxy: A #UDisksPartitionTableProxy.
 * @out_created_partition: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_partition_table_call_create_partition().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_partition_table_call_create_partition().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_table_call_create_partition_finish (
    UDisksPartitionTable *proxy,
    gchar ** out_created_partition,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_created_partition);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_table_call_create_partition_sync:
 * @proxy: A #UDisksPartitionTableProxy.
 * @arg_offset: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_type: Argument to pass with the method invocation.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_created_partition: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-PartitionTable.CreatePartition">CreatePartition()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_partition_table_call_create_partition() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_table_call_create_partition_sync (
    UDisksPartitionTable *proxy,
    guint64 arg_offset,
    guint64 arg_size,
    const gchar *arg_type,
    const gchar *arg_name,
    GVariant *arg_options,
    gchar ** out_created_partition,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CreatePartition",
    g_variant_new ("(ttss@a{sv})",
                   arg_offset,
                   arg_size,
                   arg_type,
                   arg_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_created_partition);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_table_call_create_partition_and_format:
 * @proxy: A #UDisksPartitionTableProxy.
 * @arg_offset: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_type: Argument to pass with the method invocation.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @arg_format_type: Argument to pass with the method invocation.
 * @arg_format_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-PartitionTable.CreatePartitionAndFormat">CreatePartitionAndFormat()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_partition_table_call_create_partition_and_format_finish() to get the result of the operation.
 *
 * See udisks_partition_table_call_create_partition_and_format_sync() for the synchronous, blocking version of this method.
 */
void
udisks_partition_table_call_create_partition_and_format (
    UDisksPartitionTable *proxy,
    guint64 arg_offset,
    guint64 arg_size,
    const gchar *arg_type,
    const gchar *arg_name,
    GVariant *arg_options,
    const gchar *arg_format_type,
    GVariant *arg_format_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CreatePartitionAndFormat",
    g_variant_new ("(ttss@a{sv}s@a{sv})",
                   arg_offset,
                   arg_size,
                   arg_type,
                   arg_name,
                   arg_options,
                   arg_format_type,
                   arg_format_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_partition_table_call_create_partition_and_format_finish:
 * @proxy: A #UDisksPartitionTableProxy.
 * @out_created_partition: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_partition_table_call_create_partition_and_format().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_partition_table_call_create_partition_and_format().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_table_call_create_partition_and_format_finish (
    UDisksPartitionTable *proxy,
    gchar ** out_created_partition,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_created_partition);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_table_call_create_partition_and_format_sync:
 * @proxy: A #UDisksPartitionTableProxy.
 * @arg_offset: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_type: Argument to pass with the method invocation.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @arg_format_type: Argument to pass with the method invocation.
 * @arg_format_options: Argument to pass with the method invocation.
 * @out_created_partition: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-PartitionTable.CreatePartitionAndFormat">CreatePartitionAndFormat()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_partition_table_call_create_partition_and_format() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_table_call_create_partition_and_format_sync (
    UDisksPartitionTable *proxy,
    guint64 arg_offset,
    guint64 arg_size,
    const gchar *arg_type,
    const gchar *arg_name,
    GVariant *arg_options,
    const gchar *arg_format_type,
    GVariant *arg_format_options,
    gchar ** out_created_partition,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CreatePartitionAndFormat",
    g_variant_new ("(ttss@a{sv}s@a{sv})",
                   arg_offset,
                   arg_size,
                   arg_type,
                   arg_name,
                   arg_options,
                   arg_format_type,
                   arg_format_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_created_partition);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_table_complete_create_partition:
 * @object: A #UDisksPartitionTable.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @created_partition: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-PartitionTable.CreatePartition">CreatePartition()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_partition_table_complete_create_partition (
    UDisksPartitionTable *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *created_partition)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   created_partition));
}

/**
 * udisks_partition_table_complete_create_partition_and_format:
 * @object: A #UDisksPartitionTable.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @created_partition: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-PartitionTable.CreatePartitionAndFormat">CreatePartitionAndFormat()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_partition_table_complete_create_partition_and_format (
    UDisksPartitionTable *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *created_partition)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   created_partition));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksPartitionTableProxy:
 *
 * The #UDisksPartitionTableProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksPartitionTableProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksPartitionTableProxy.
 */

struct _UDisksPartitionTableProxyPrivate
{
  GData *qdata;
};

static void udisks_partition_table_proxy_iface_init (UDisksPartitionTableIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksPartitionTableProxy, udisks_partition_table_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksPartitionTableProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_PARTITION_TABLE, udisks_partition_table_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksPartitionTableProxy, udisks_partition_table_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_PARTITION_TABLE, udisks_partition_table_proxy_iface_init))

#endif
static void
udisks_partition_table_proxy_finalize (GObject *object)
{
  UDisksPartitionTableProxy *proxy = UDISKS_PARTITION_TABLE_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_partition_table_proxy_parent_class)->finalize (object);
}

static void
udisks_partition_table_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 2);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_partition_table_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_partition_table_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.PartitionTable: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_partition_table_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 2);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_partition_table_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.PartitionTable", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_partition_table_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_partition_table_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_partition_table_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_PARTITION_TABLE);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_PARTITION_TABLE);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_partition_table_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksPartitionTableProxy *proxy = UDISKS_PARTITION_TABLE_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_partition_table_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_partition_table_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *const *
udisks_partition_table_proxy_get_partitions (UDisksPartitionTable *object)
{
  UDisksPartitionTableProxy *proxy = UDISKS_PARTITION_TABLE_PROXY (object);
  GVariant *variant;
  const gchar *const *value = NULL;
  value = g_datalist_get_data (&proxy->priv->qdata, "Partitions");
  if (value != NULL)
    return value;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Partitions");
  if (variant != NULL)
    {
      value = g_variant_get_objv (variant, NULL);
      g_datalist_set_data_full (&proxy->priv->qdata, "Partitions", (gpointer) value, g_free);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_partition_table_proxy_get_type_ (UDisksPartitionTable *object)
{
  UDisksPartitionTableProxy *proxy = UDISKS_PARTITION_TABLE_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Type");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_partition_table_proxy_init (UDisksPartitionTableProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_partition_table_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_PARTITION_TABLE_PROXY, UDisksPartitionTableProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_partition_table_interface_info ());
}

static void
udisks_partition_table_proxy_class_init (UDisksPartitionTableProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_partition_table_proxy_finalize;
  gobject_class->get_property = udisks_partition_table_proxy_get_property;
  gobject_class->set_property = udisks_partition_table_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_partition_table_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_partition_table_proxy_g_properties_changed;

  udisks_partition_table_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksPartitionTableProxyPrivate));
#endif
}

static void
udisks_partition_table_proxy_iface_init (UDisksPartitionTableIface *iface)
{
  iface->get_partitions = udisks_partition_table_proxy_get_partitions;
  iface->get_type_ = udisks_partition_table_proxy_get_type_;
}

/**
 * udisks_partition_table_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PartitionTable.top_of_page">org.freedesktop.UDisks2.PartitionTable</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_partition_table_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_partition_table_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_partition_table_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_PARTITION_TABLE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.PartitionTable", NULL);
}

/**
 * udisks_partition_table_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_partition_table_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_partition_table_proxy_new().
 *
 * Returns: (transfer full) (type UDisksPartitionTableProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksPartitionTable *
udisks_partition_table_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_PARTITION_TABLE (ret);
  else
    return NULL;
}

/**
 * udisks_partition_table_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PartitionTable.top_of_page">org.freedesktop.UDisks2.PartitionTable</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_partition_table_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksPartitionTableProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksPartitionTable *
udisks_partition_table_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_PARTITION_TABLE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.PartitionTable", NULL);
  if (ret != NULL)
    return UDISKS_PARTITION_TABLE (ret);
  else
    return NULL;
}


/**
 * udisks_partition_table_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_partition_table_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_partition_table_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_partition_table_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_partition_table_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_PARTITION_TABLE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.PartitionTable", NULL);
}

/**
 * udisks_partition_table_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_partition_table_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_partition_table_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksPartitionTableProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksPartitionTable *
udisks_partition_table_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_PARTITION_TABLE (ret);
  else
    return NULL;
}

/**
 * udisks_partition_table_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_partition_table_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_partition_table_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksPartitionTableProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksPartitionTable *
udisks_partition_table_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_PARTITION_TABLE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.PartitionTable", NULL);
  if (ret != NULL)
    return UDISKS_PARTITION_TABLE (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksPartitionTableSkeleton:
 *
 * The #UDisksPartitionTableSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksPartitionTableSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksPartitionTableSkeleton.
 */

struct _UDisksPartitionTableSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_partition_table_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksPartitionTableSkeleton *skeleton = UDISKS_PARTITION_TABLE_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_PARTITION_TABLE);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_PARTITION_TABLE);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_partition_table_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksPartitionTableSkeleton *skeleton = UDISKS_PARTITION_TABLE_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_partition_table_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_partition_table_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksPartitionTableSkeleton *skeleton = UDISKS_PARTITION_TABLE_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_partition_table_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_partition_table_skeleton_vtable =
{
  _udisks_partition_table_skeleton_handle_method_call,
  _udisks_partition_table_skeleton_handle_get_property,
  _udisks_partition_table_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_partition_table_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_partition_table_interface_info ();
}

static GDBusInterfaceVTable *
udisks_partition_table_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_partition_table_skeleton_vtable;
}

static GVariant *
udisks_partition_table_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksPartitionTableSkeleton *skeleton = UDISKS_PARTITION_TABLE_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_partition_table_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_partition_table_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_partition_table_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_partition_table_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.PartitionTable", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_partition_table_emit_changed (gpointer user_data);

static void
udisks_partition_table_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksPartitionTableSkeleton *skeleton = UDISKS_PARTITION_TABLE_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_partition_table_emit_changed (skeleton);
}

static void udisks_partition_table_skeleton_iface_init (UDisksPartitionTableIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksPartitionTableSkeleton, udisks_partition_table_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksPartitionTableSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_PARTITION_TABLE, udisks_partition_table_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksPartitionTableSkeleton, udisks_partition_table_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_PARTITION_TABLE, udisks_partition_table_skeleton_iface_init))

#endif
static void
udisks_partition_table_skeleton_finalize (GObject *object)
{
  UDisksPartitionTableSkeleton *skeleton = UDISKS_PARTITION_TABLE_SKELETON (object);
  guint n;
  for (n = 0; n < 2; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_partition_table_skeleton_parent_class)->finalize (object);
}

static void
udisks_partition_table_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksPartitionTableSkeleton *skeleton = UDISKS_PARTITION_TABLE_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 2);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_partition_table_emit_changed (gpointer user_data)
{
  UDisksPartitionTableSkeleton *skeleton = UDISKS_PARTITION_TABLE_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.PartitionTable",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_partition_table_schedule_emit_changed (UDisksPartitionTableSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_partition_table_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksPartitionTableSkeleton *skeleton = UDISKS_PARTITION_TABLE_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_partition_table_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_partition_table_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_partition_table_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksPartitionTableSkeleton *skeleton = UDISKS_PARTITION_TABLE_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 2);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_partition_table_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_partition_table_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_partition_table_skeleton_init (UDisksPartitionTableSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_partition_table_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_PARTITION_TABLE_SKELETON, UDisksPartitionTableSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 2);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRV);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING);
}

static const gchar *const *
udisks_partition_table_skeleton_get_partitions (UDisksPartitionTable *object)
{
  UDisksPartitionTableSkeleton *skeleton = UDISKS_PARTITION_TABLE_SKELETON (object);
  const gchar *const *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boxed (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_partition_table_skeleton_get_type_ (UDisksPartitionTable *object)
{
  UDisksPartitionTableSkeleton *skeleton = UDISKS_PARTITION_TABLE_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_partition_table_skeleton_class_init (UDisksPartitionTableSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_partition_table_skeleton_finalize;
  gobject_class->get_property = udisks_partition_table_skeleton_get_property;
  gobject_class->set_property = udisks_partition_table_skeleton_set_property;
  gobject_class->notify       = udisks_partition_table_skeleton_notify;


  udisks_partition_table_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_partition_table_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_partition_table_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_partition_table_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_partition_table_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksPartitionTableSkeletonPrivate));
#endif
}

static void
udisks_partition_table_skeleton_iface_init (UDisksPartitionTableIface *iface)
{
  iface->get_partitions = udisks_partition_table_skeleton_get_partitions;
  iface->get_type_ = udisks_partition_table_skeleton_get_type_;
}

/**
 * udisks_partition_table_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PartitionTable.top_of_page">org.freedesktop.UDisks2.PartitionTable</link>.
 *
 * Returns: (transfer full) (type UDisksPartitionTableSkeleton): The skeleton object.
 */
UDisksPartitionTable *
udisks_partition_table_skeleton_new (void)
{
  return UDISKS_PARTITION_TABLE (g_object_new (UDISKS_TYPE_PARTITION_TABLE_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Partition
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksPartition
 * @title: UDisksPartition
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Partition D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Partition.top_of_page">org.freedesktop.UDisks2.Partition</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Partition ---- */

static const _ExtendedGDBusArgInfo _udisks_partition_method_info_set_type_IN_ARG_type =
{
  {
    -1,
    (gchar *) "type",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_method_info_set_type_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_partition_method_info_set_type_IN_ARG_pointers[] =
{
  &_udisks_partition_method_info_set_type_IN_ARG_type.parent_struct,
  &_udisks_partition_method_info_set_type_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_partition_method_info_set_type =
{
  {
    -1,
    (gchar *) "SetType",
    (GDBusArgInfo **) &_udisks_partition_method_info_set_type_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-type",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_method_info_set_name_IN_ARG_name =
{
  {
    -1,
    (gchar *) "name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_method_info_set_name_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_partition_method_info_set_name_IN_ARG_pointers[] =
{
  &_udisks_partition_method_info_set_name_IN_ARG_name.parent_struct,
  &_udisks_partition_method_info_set_name_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_partition_method_info_set_name =
{
  {
    -1,
    (gchar *) "SetName",
    (GDBusArgInfo **) &_udisks_partition_method_info_set_name_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-name",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_method_info_set_uuid_IN_ARG_uuid =
{
  {
    -1,
    (gchar *) "uuid",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_method_info_set_uuid_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_partition_method_info_set_uuid_IN_ARG_pointers[] =
{
  &_udisks_partition_method_info_set_uuid_IN_ARG_uuid.parent_struct,
  &_udisks_partition_method_info_set_uuid_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_partition_method_info_set_uuid =
{
  {
    -1,
    (gchar *) "SetUUID",
    (GDBusArgInfo **) &_udisks_partition_method_info_set_uuid_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-uuid",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_method_info_set_flags_IN_ARG_flags =
{
  {
    -1,
    (gchar *) "flags",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_method_info_set_flags_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_partition_method_info_set_flags_IN_ARG_pointers[] =
{
  &_udisks_partition_method_info_set_flags_IN_ARG_flags.parent_struct,
  &_udisks_partition_method_info_set_flags_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_partition_method_info_set_flags =
{
  {
    -1,
    (gchar *) "SetFlags",
    (GDBusArgInfo **) &_udisks_partition_method_info_set_flags_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-flags",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_method_info_resize_IN_ARG_size =
{
  {
    -1,
    (gchar *) "size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_method_info_resize_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_partition_method_info_resize_IN_ARG_pointers[] =
{
  &_udisks_partition_method_info_resize_IN_ARG_size.parent_struct,
  &_udisks_partition_method_info_resize_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_partition_method_info_resize =
{
  {
    -1,
    (gchar *) "Resize",
    (GDBusArgInfo **) &_udisks_partition_method_info_resize_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-resize",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_partition_method_info_delete_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_partition_method_info_delete_IN_ARG_pointers[] =
{
  &_udisks_partition_method_info_delete_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_partition_method_info_delete =
{
  {
    -1,
    (gchar *) "Delete",
    (GDBusArgInfo **) &_udisks_partition_method_info_delete_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-delete",
  FALSE
};

static const GDBusMethodInfo * const _udisks_partition_method_info_pointers[] =
{
  &_udisks_partition_method_info_set_type.parent_struct,
  &_udisks_partition_method_info_set_name.parent_struct,
  &_udisks_partition_method_info_set_uuid.parent_struct,
  &_udisks_partition_method_info_set_flags.parent_struct,
  &_udisks_partition_method_info_resize.parent_struct,
  &_udisks_partition_method_info_delete.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_partition_property_info_number =
{
  {
    -1,
    (gchar *) "Number",
    (gchar *) "u",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "number",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_partition_property_info_type_ =
{
  {
    -1,
    (gchar *) "Type",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "type",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_partition_property_info_flags =
{
  {
    -1,
    (gchar *) "Flags",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "flags",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_partition_property_info_offset =
{
  {
    -1,
    (gchar *) "Offset",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "offset",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_partition_property_info_size =
{
  {
    -1,
    (gchar *) "Size",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "size",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_partition_property_info_name =
{
  {
    -1,
    (gchar *) "Name",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "name",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_partition_property_info_uuid =
{
  {
    -1,
    (gchar *) "UUID",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "uuid",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_partition_property_info_table =
{
  {
    -1,
    (gchar *) "Table",
    (gchar *) "o",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "table",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_partition_property_info_is_container =
{
  {
    -1,
    (gchar *) "IsContainer",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "is-container",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_partition_property_info_is_contained =
{
  {
    -1,
    (gchar *) "IsContained",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "is-contained",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_partition_property_info_pointers[] =
{
  &_udisks_partition_property_info_number.parent_struct,
  &_udisks_partition_property_info_type_.parent_struct,
  &_udisks_partition_property_info_flags.parent_struct,
  &_udisks_partition_property_info_offset.parent_struct,
  &_udisks_partition_property_info_size.parent_struct,
  &_udisks_partition_property_info_name.parent_struct,
  &_udisks_partition_property_info_uuid.parent_struct,
  &_udisks_partition_property_info_table.parent_struct,
  &_udisks_partition_property_info_is_container.parent_struct,
  &_udisks_partition_property_info_is_contained.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_partition_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Partition",
    (GDBusMethodInfo **) &_udisks_partition_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_partition_property_info_pointers,
    NULL
  },
  "partition",
};


/**
 * udisks_partition_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Partition.top_of_page">org.freedesktop.UDisks2.Partition</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_partition_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_partition_interface_info.parent_struct;
}

/**
 * udisks_partition_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksPartition interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_partition_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "number");
  g_object_class_override_property (klass, property_id_begin++, "type");
  g_object_class_override_property (klass, property_id_begin++, "flags");
  g_object_class_override_property (klass, property_id_begin++, "offset");
  g_object_class_override_property (klass, property_id_begin++, "size");
  g_object_class_override_property (klass, property_id_begin++, "name");
  g_object_class_override_property (klass, property_id_begin++, "uuid");
  g_object_class_override_property (klass, property_id_begin++, "table");
  g_object_class_override_property (klass, property_id_begin++, "is-container");
  g_object_class_override_property (klass, property_id_begin++, "is-contained");
  return property_id_begin - 1;
}


inline static void
udisks_partition_method_marshal_set_type (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_partition_method_marshal_set_name (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_partition_method_marshal_set_uuid (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_partition_method_marshal_set_flags (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT64_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_partition_method_marshal_resize (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT64_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_partition_method_marshal_delete (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksPartition:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Partition.top_of_page">org.freedesktop.UDisks2.Partition</link>.
 */

/**
 * UDisksPartitionIface:
 * @parent_iface: The parent interface.
 * @handle_delete: Handler for the #UDisksPartition::handle-delete signal.
 * @handle_resize: Handler for the #UDisksPartition::handle-resize signal.
 * @handle_set_flags: Handler for the #UDisksPartition::handle-set-flags signal.
 * @handle_set_name: Handler for the #UDisksPartition::handle-set-name signal.
 * @handle_set_type: Handler for the #UDisksPartition::handle-set-type signal.
 * @get_flags: Getter for the #UDisksPartition:flags property.
 * @get_is_contained: Getter for the #UDisksPartition:is-contained property.
 * @get_is_container: Getter for the #UDisksPartition:is-container property.
 * @get_name: Getter for the #UDisksPartition:name property.
 * @get_number: Getter for the #UDisksPartition:number property.
 * @get_offset: Getter for the #UDisksPartition:offset property.
 * @get_size: Getter for the #UDisksPartition:size property.
 * @get_table: Getter for the #UDisksPartition:table property.
 * @get_type_: Getter for the #UDisksPartition:type property.
 * @get_uuid: Getter for the #UDisksPartition:uuid property.
 * @handle_set_uuid: Handler for the #UDisksPartition::handle-set-uuid signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Partition.top_of_page">org.freedesktop.UDisks2.Partition</link>.
 */

typedef UDisksPartitionIface UDisksPartitionInterface;
G_DEFINE_INTERFACE (UDisksPartition, udisks_partition, G_TYPE_OBJECT)

static void
udisks_partition_default_init (UDisksPartitionIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksPartition::handle-set-type:
   * @object: A #UDisksPartition.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_type: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetType">SetType()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_partition_complete_set_type() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-set-type",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksPartitionIface, handle_set_type),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_partition_method_marshal_set_type,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksPartition::handle-set-name:
   * @object: A #UDisksPartition.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_name: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetName">SetName()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_partition_complete_set_name() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-set-name",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksPartitionIface, handle_set_name),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_partition_method_marshal_set_name,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksPartition::handle-set-uuid:
   * @object: A #UDisksPartition.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_uuid: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetUUID">SetUUID()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_partition_complete_set_uuid() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.10.0
   */
  g_signal_new ("handle-set-uuid",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksPartitionIface, handle_set_uuid),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_partition_method_marshal_set_uuid,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksPartition::handle-set-flags:
   * @object: A #UDisksPartition.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_flags: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetFlags">SetFlags()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_partition_complete_set_flags() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-set-flags",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksPartitionIface, handle_set_flags),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_partition_method_marshal_set_flags,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT64, G_TYPE_VARIANT);

  /**
   * UDisksPartition::handle-resize:
   * @object: A #UDisksPartition.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_size: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.Resize">Resize()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_partition_complete_resize() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-resize",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksPartitionIface, handle_resize),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_partition_method_marshal_resize,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT64, G_TYPE_VARIANT);

  /**
   * UDisksPartition::handle-delete:
   * @object: A #UDisksPartition.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.Delete">Delete()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_partition_complete_delete() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-delete",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksPartitionIface, handle_delete),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_partition_method_marshal_delete,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksPartition:number:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Number">"Number"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint ("number", "Number", "Number", 0, G_MAXUINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksPartition:type:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Type">"Type"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("type", "Type", "Type", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksPartition:flags:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Flags">"Flags"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("flags", "Flags", "Flags", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksPartition:offset:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Offset">"Offset"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("offset", "Offset", "Offset", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksPartition:size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Size">"Size"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("size", "Size", "Size", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksPartition:name:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Name">"Name"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("name", "Name", "Name", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksPartition:uuid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.UUID">"UUID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("uuid", "UUID", "UUID", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksPartition:table:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Table">"Table"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("table", "Table", "Table", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksPartition:is-container:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.IsContainer">"IsContainer"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("is-container", "IsContainer", "IsContainer", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksPartition:is-contained:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.IsContained">"IsContained"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("is-contained", "IsContained", "IsContained", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_partition_get_number: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Number">"Number"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint 
udisks_partition_get_number (UDisksPartition *object)
{
  g_return_val_if_fail (UDISKS_IS_PARTITION (object), 0);

  return UDISKS_PARTITION_GET_IFACE (object)->get_number (object);
}

/**
 * udisks_partition_set_number: (skip)
 * @object: A #UDisksPartition.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Number">"Number"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_partition_set_number (UDisksPartition *object, guint value)
{
  g_object_set (G_OBJECT (object), "number", value, NULL);
}

/**
 * udisks_partition_get_type_: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Type">"Type"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_partition_dup_type_() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_partition_get_type_ (UDisksPartition *object)
{
  g_return_val_if_fail (UDISKS_IS_PARTITION (object), NULL);

  return UDISKS_PARTITION_GET_IFACE (object)->get_type_ (object);
}

/**
 * udisks_partition_dup_type_: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Type">"Type"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_partition_dup_type_ (UDisksPartition *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "type", &value, NULL);
  return value;
}

/**
 * udisks_partition_set_type_: (skip)
 * @object: A #UDisksPartition.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Type">"Type"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_partition_set_type_ (UDisksPartition *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "type", value, NULL);
}

/**
 * udisks_partition_get_flags: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Flags">"Flags"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_partition_get_flags (UDisksPartition *object)
{
  g_return_val_if_fail (UDISKS_IS_PARTITION (object), 0);

  return UDISKS_PARTITION_GET_IFACE (object)->get_flags (object);
}

/**
 * udisks_partition_set_flags: (skip)
 * @object: A #UDisksPartition.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Flags">"Flags"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_partition_set_flags (UDisksPartition *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "flags", value, NULL);
}

/**
 * udisks_partition_get_offset: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Offset">"Offset"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_partition_get_offset (UDisksPartition *object)
{
  g_return_val_if_fail (UDISKS_IS_PARTITION (object), 0);

  return UDISKS_PARTITION_GET_IFACE (object)->get_offset (object);
}

/**
 * udisks_partition_set_offset: (skip)
 * @object: A #UDisksPartition.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Offset">"Offset"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_partition_set_offset (UDisksPartition *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "offset", value, NULL);
}

/**
 * udisks_partition_get_size: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Size">"Size"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_partition_get_size (UDisksPartition *object)
{
  g_return_val_if_fail (UDISKS_IS_PARTITION (object), 0);

  return UDISKS_PARTITION_GET_IFACE (object)->get_size (object);
}

/**
 * udisks_partition_set_size: (skip)
 * @object: A #UDisksPartition.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Size">"Size"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_partition_set_size (UDisksPartition *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "size", value, NULL);
}

/**
 * udisks_partition_get_name: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Name">"Name"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_partition_dup_name() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_partition_get_name (UDisksPartition *object)
{
  g_return_val_if_fail (UDISKS_IS_PARTITION (object), NULL);

  return UDISKS_PARTITION_GET_IFACE (object)->get_name (object);
}

/**
 * udisks_partition_dup_name: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Name">"Name"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_partition_dup_name (UDisksPartition *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "name", &value, NULL);
  return value;
}

/**
 * udisks_partition_set_name: (skip)
 * @object: A #UDisksPartition.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Name">"Name"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_partition_set_name (UDisksPartition *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "name", value, NULL);
}

/**
 * udisks_partition_get_uuid: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.UUID">"UUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_partition_dup_uuid() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_partition_get_uuid (UDisksPartition *object)
{
  g_return_val_if_fail (UDISKS_IS_PARTITION (object), NULL);

  return UDISKS_PARTITION_GET_IFACE (object)->get_uuid (object);
}

/**
 * udisks_partition_dup_uuid: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.UUID">"UUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_partition_dup_uuid (UDisksPartition *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "uuid", &value, NULL);
  return value;
}

/**
 * udisks_partition_set_uuid: (skip)
 * @object: A #UDisksPartition.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.UUID">"UUID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_partition_set_uuid (UDisksPartition *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "uuid", value, NULL);
}

/**
 * udisks_partition_get_table: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Table">"Table"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_partition_dup_table() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_partition_get_table (UDisksPartition *object)
{
  g_return_val_if_fail (UDISKS_IS_PARTITION (object), NULL);

  return UDISKS_PARTITION_GET_IFACE (object)->get_table (object);
}

/**
 * udisks_partition_dup_table: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Table">"Table"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_partition_dup_table (UDisksPartition *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "table", &value, NULL);
  return value;
}

/**
 * udisks_partition_set_table: (skip)
 * @object: A #UDisksPartition.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.Table">"Table"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_partition_set_table (UDisksPartition *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "table", value, NULL);
}

/**
 * udisks_partition_get_is_container: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.IsContainer">"IsContainer"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_partition_get_is_container (UDisksPartition *object)
{
  g_return_val_if_fail (UDISKS_IS_PARTITION (object), FALSE);

  return UDISKS_PARTITION_GET_IFACE (object)->get_is_container (object);
}

/**
 * udisks_partition_set_is_container: (skip)
 * @object: A #UDisksPartition.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.IsContainer">"IsContainer"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_partition_set_is_container (UDisksPartition *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "is-container", value, NULL);
}

/**
 * udisks_partition_get_is_contained: (skip)
 * @object: A #UDisksPartition.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.IsContained">"IsContained"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_partition_get_is_contained (UDisksPartition *object)
{
  g_return_val_if_fail (UDISKS_IS_PARTITION (object), FALSE);

  return UDISKS_PARTITION_GET_IFACE (object)->get_is_contained (object);
}

/**
 * udisks_partition_set_is_contained: (skip)
 * @object: A #UDisksPartition.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Partition.IsContained">"IsContained"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_partition_set_is_contained (UDisksPartition *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "is-contained", value, NULL);
}

/**
 * udisks_partition_call_set_type:
 * @proxy: A #UDisksPartitionProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetType">SetType()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_partition_call_set_type_finish() to get the result of the operation.
 *
 * See udisks_partition_call_set_type_sync() for the synchronous, blocking version of this method.
 */
void
udisks_partition_call_set_type (
    UDisksPartition *proxy,
    const gchar *arg_type,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetType",
    g_variant_new ("(s@a{sv})",
                   arg_type,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_partition_call_set_type_finish:
 * @proxy: A #UDisksPartitionProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_partition_call_set_type().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_partition_call_set_type().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_call_set_type_finish (
    UDisksPartition *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_call_set_type_sync:
 * @proxy: A #UDisksPartitionProxy.
 * @arg_type: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetType">SetType()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_partition_call_set_type() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_call_set_type_sync (
    UDisksPartition *proxy,
    const gchar *arg_type,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetType",
    g_variant_new ("(s@a{sv})",
                   arg_type,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_call_set_name:
 * @proxy: A #UDisksPartitionProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetName">SetName()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_partition_call_set_name_finish() to get the result of the operation.
 *
 * See udisks_partition_call_set_name_sync() for the synchronous, blocking version of this method.
 */
void
udisks_partition_call_set_name (
    UDisksPartition *proxy,
    const gchar *arg_name,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetName",
    g_variant_new ("(s@a{sv})",
                   arg_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_partition_call_set_name_finish:
 * @proxy: A #UDisksPartitionProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_partition_call_set_name().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_partition_call_set_name().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_call_set_name_finish (
    UDisksPartition *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_call_set_name_sync:
 * @proxy: A #UDisksPartitionProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetName">SetName()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_partition_call_set_name() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_call_set_name_sync (
    UDisksPartition *proxy,
    const gchar *arg_name,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetName",
    g_variant_new ("(s@a{sv})",
                   arg_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_call_set_uuid:
 * @proxy: A #UDisksPartitionProxy.
 * @arg_uuid: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetUUID">SetUUID()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_partition_call_set_uuid_finish() to get the result of the operation.
 *
 * See udisks_partition_call_set_uuid_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.10.0
 */
void
udisks_partition_call_set_uuid (
    UDisksPartition *proxy,
    const gchar *arg_uuid,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetUUID",
    g_variant_new ("(s@a{sv})",
                   arg_uuid,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_partition_call_set_uuid_finish:
 * @proxy: A #UDisksPartitionProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_partition_call_set_uuid().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_partition_call_set_uuid().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_partition_call_set_uuid_finish (
    UDisksPartition *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_call_set_uuid_sync:
 * @proxy: A #UDisksPartitionProxy.
 * @arg_uuid: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetUUID">SetUUID()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_partition_call_set_uuid() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_partition_call_set_uuid_sync (
    UDisksPartition *proxy,
    const gchar *arg_uuid,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetUUID",
    g_variant_new ("(s@a{sv})",
                   arg_uuid,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_call_set_flags:
 * @proxy: A #UDisksPartitionProxy.
 * @arg_flags: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetFlags">SetFlags()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_partition_call_set_flags_finish() to get the result of the operation.
 *
 * See udisks_partition_call_set_flags_sync() for the synchronous, blocking version of this method.
 */
void
udisks_partition_call_set_flags (
    UDisksPartition *proxy,
    guint64 arg_flags,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetFlags",
    g_variant_new ("(t@a{sv})",
                   arg_flags,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_partition_call_set_flags_finish:
 * @proxy: A #UDisksPartitionProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_partition_call_set_flags().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_partition_call_set_flags().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_call_set_flags_finish (
    UDisksPartition *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_call_set_flags_sync:
 * @proxy: A #UDisksPartitionProxy.
 * @arg_flags: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetFlags">SetFlags()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_partition_call_set_flags() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_call_set_flags_sync (
    UDisksPartition *proxy,
    guint64 arg_flags,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetFlags",
    g_variant_new ("(t@a{sv})",
                   arg_flags,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_call_resize:
 * @proxy: A #UDisksPartitionProxy.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.Resize">Resize()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_partition_call_resize_finish() to get the result of the operation.
 *
 * See udisks_partition_call_resize_sync() for the synchronous, blocking version of this method.
 */
void
udisks_partition_call_resize (
    UDisksPartition *proxy,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Resize",
    g_variant_new ("(t@a{sv})",
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_partition_call_resize_finish:
 * @proxy: A #UDisksPartitionProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_partition_call_resize().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_partition_call_resize().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_call_resize_finish (
    UDisksPartition *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_call_resize_sync:
 * @proxy: A #UDisksPartitionProxy.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.Resize">Resize()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_partition_call_resize() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_call_resize_sync (
    UDisksPartition *proxy,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Resize",
    g_variant_new ("(t@a{sv})",
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_call_delete:
 * @proxy: A #UDisksPartitionProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.Delete">Delete()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_partition_call_delete_finish() to get the result of the operation.
 *
 * See udisks_partition_call_delete_sync() for the synchronous, blocking version of this method.
 */
void
udisks_partition_call_delete (
    UDisksPartition *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Delete",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_partition_call_delete_finish:
 * @proxy: A #UDisksPartitionProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_partition_call_delete().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_partition_call_delete().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_call_delete_finish (
    UDisksPartition *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_call_delete_sync:
 * @proxy: A #UDisksPartitionProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.Delete">Delete()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_partition_call_delete() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_partition_call_delete_sync (
    UDisksPartition *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Delete",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_partition_complete_set_type:
 * @object: A #UDisksPartition.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetType">SetType()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_partition_complete_set_type (
    UDisksPartition *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_partition_complete_set_name:
 * @object: A #UDisksPartition.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetName">SetName()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_partition_complete_set_name (
    UDisksPartition *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_partition_complete_set_uuid:
 * @object: A #UDisksPartition.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetUUID">SetUUID()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.10.0
 */
void
udisks_partition_complete_set_uuid (
    UDisksPartition *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_partition_complete_set_flags:
 * @object: A #UDisksPartition.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.SetFlags">SetFlags()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_partition_complete_set_flags (
    UDisksPartition *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_partition_complete_resize:
 * @object: A #UDisksPartition.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.Resize">Resize()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_partition_complete_resize (
    UDisksPartition *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_partition_complete_delete:
 * @object: A #UDisksPartition.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Partition.Delete">Delete()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_partition_complete_delete (
    UDisksPartition *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksPartitionProxy:
 *
 * The #UDisksPartitionProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksPartitionProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksPartitionProxy.
 */

struct _UDisksPartitionProxyPrivate
{
  GData *qdata;
};

static void udisks_partition_proxy_iface_init (UDisksPartitionIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksPartitionProxy, udisks_partition_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksPartitionProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_PARTITION, udisks_partition_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksPartitionProxy, udisks_partition_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_PARTITION, udisks_partition_proxy_iface_init))

#endif
static void
udisks_partition_proxy_finalize (GObject *object)
{
  UDisksPartitionProxy *proxy = UDISKS_PARTITION_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_partition_proxy_parent_class)->finalize (object);
}

static void
udisks_partition_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 10);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_partition_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_partition_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.Partition: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_partition_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 10);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_partition_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.Partition", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_partition_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_partition_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_partition_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_PARTITION);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_PARTITION);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_partition_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksPartitionProxy *proxy = UDISKS_PARTITION_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_partition_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_partition_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static guint 
udisks_partition_proxy_get_number (UDisksPartition *object)
{
  UDisksPartitionProxy *proxy = UDISKS_PARTITION_PROXY (object);
  GVariant *variant;
  guint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Number");
  if (variant != NULL)
    {
      value = g_variant_get_uint32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_partition_proxy_get_type_ (UDisksPartition *object)
{
  UDisksPartitionProxy *proxy = UDISKS_PARTITION_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Type");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_partition_proxy_get_flags (UDisksPartition *object)
{
  UDisksPartitionProxy *proxy = UDISKS_PARTITION_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Flags");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_partition_proxy_get_offset (UDisksPartition *object)
{
  UDisksPartitionProxy *proxy = UDISKS_PARTITION_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Offset");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_partition_proxy_get_size (UDisksPartition *object)
{
  UDisksPartitionProxy *proxy = UDISKS_PARTITION_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Size");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_partition_proxy_get_name (UDisksPartition *object)
{
  UDisksPartitionProxy *proxy = UDISKS_PARTITION_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Name");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_partition_proxy_get_uuid (UDisksPartition *object)
{
  UDisksPartitionProxy *proxy = UDISKS_PARTITION_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "UUID");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_partition_proxy_get_table (UDisksPartition *object)
{
  UDisksPartitionProxy *proxy = UDISKS_PARTITION_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Table");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_partition_proxy_get_is_container (UDisksPartition *object)
{
  UDisksPartitionProxy *proxy = UDISKS_PARTITION_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "IsContainer");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_partition_proxy_get_is_contained (UDisksPartition *object)
{
  UDisksPartitionProxy *proxy = UDISKS_PARTITION_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "IsContained");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_partition_proxy_init (UDisksPartitionProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_partition_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_PARTITION_PROXY, UDisksPartitionProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_partition_interface_info ());
}

static void
udisks_partition_proxy_class_init (UDisksPartitionProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_partition_proxy_finalize;
  gobject_class->get_property = udisks_partition_proxy_get_property;
  gobject_class->set_property = udisks_partition_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_partition_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_partition_proxy_g_properties_changed;

  udisks_partition_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksPartitionProxyPrivate));
#endif
}

static void
udisks_partition_proxy_iface_init (UDisksPartitionIface *iface)
{
  iface->get_number = udisks_partition_proxy_get_number;
  iface->get_type_ = udisks_partition_proxy_get_type_;
  iface->get_flags = udisks_partition_proxy_get_flags;
  iface->get_offset = udisks_partition_proxy_get_offset;
  iface->get_size = udisks_partition_proxy_get_size;
  iface->get_name = udisks_partition_proxy_get_name;
  iface->get_uuid = udisks_partition_proxy_get_uuid;
  iface->get_table = udisks_partition_proxy_get_table;
  iface->get_is_container = udisks_partition_proxy_get_is_container;
  iface->get_is_contained = udisks_partition_proxy_get_is_contained;
}

/**
 * udisks_partition_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Partition.top_of_page">org.freedesktop.UDisks2.Partition</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_partition_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_partition_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_partition_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_PARTITION_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Partition", NULL);
}

/**
 * udisks_partition_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_partition_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_partition_proxy_new().
 *
 * Returns: (transfer full) (type UDisksPartitionProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksPartition *
udisks_partition_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_PARTITION (ret);
  else
    return NULL;
}

/**
 * udisks_partition_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Partition.top_of_page">org.freedesktop.UDisks2.Partition</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_partition_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksPartitionProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksPartition *
udisks_partition_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_PARTITION_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Partition", NULL);
  if (ret != NULL)
    return UDISKS_PARTITION (ret);
  else
    return NULL;
}


/**
 * udisks_partition_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_partition_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_partition_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_partition_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_partition_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_PARTITION_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Partition", NULL);
}

/**
 * udisks_partition_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_partition_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_partition_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksPartitionProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksPartition *
udisks_partition_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_PARTITION (ret);
  else
    return NULL;
}

/**
 * udisks_partition_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_partition_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_partition_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksPartitionProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksPartition *
udisks_partition_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_PARTITION_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Partition", NULL);
  if (ret != NULL)
    return UDISKS_PARTITION (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksPartitionSkeleton:
 *
 * The #UDisksPartitionSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksPartitionSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksPartitionSkeleton.
 */

struct _UDisksPartitionSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_partition_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_PARTITION);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_PARTITION);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_partition_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_partition_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_partition_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_partition_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_partition_skeleton_vtable =
{
  _udisks_partition_skeleton_handle_method_call,
  _udisks_partition_skeleton_handle_get_property,
  _udisks_partition_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_partition_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_partition_interface_info ();
}

static GDBusInterfaceVTable *
udisks_partition_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_partition_skeleton_vtable;
}

static GVariant *
udisks_partition_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_partition_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_partition_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_partition_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_partition_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Partition", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_partition_emit_changed (gpointer user_data);

static void
udisks_partition_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_partition_emit_changed (skeleton);
}

static void udisks_partition_skeleton_iface_init (UDisksPartitionIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksPartitionSkeleton, udisks_partition_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksPartitionSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_PARTITION, udisks_partition_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksPartitionSkeleton, udisks_partition_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_PARTITION, udisks_partition_skeleton_iface_init))

#endif
static void
udisks_partition_skeleton_finalize (GObject *object)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  guint n;
  for (n = 0; n < 10; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_partition_skeleton_parent_class)->finalize (object);
}

static void
udisks_partition_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 10);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_partition_emit_changed (gpointer user_data)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.Partition",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_partition_schedule_emit_changed (UDisksPartitionSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_partition_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_partition_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_partition_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_partition_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 10);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_partition_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_partition_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_partition_skeleton_init (UDisksPartitionSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_partition_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_PARTITION_SKELETON, UDisksPartitionSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 10);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_UINT);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[4], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[5], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[6], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[7], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[8], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[9], G_TYPE_BOOLEAN);
}

static guint 
udisks_partition_skeleton_get_number (UDisksPartition *object)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  guint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_partition_skeleton_get_type_ (UDisksPartition *object)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_partition_skeleton_get_flags (UDisksPartition *object)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_partition_skeleton_get_offset (UDisksPartition *object)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_partition_skeleton_get_size (UDisksPartition *object)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[4]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_partition_skeleton_get_name (UDisksPartition *object)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[5]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_partition_skeleton_get_uuid (UDisksPartition *object)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[6]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_partition_skeleton_get_table (UDisksPartition *object)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[7]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_partition_skeleton_get_is_container (UDisksPartition *object)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[8]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_partition_skeleton_get_is_contained (UDisksPartition *object)
{
  UDisksPartitionSkeleton *skeleton = UDISKS_PARTITION_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[9]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_partition_skeleton_class_init (UDisksPartitionSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_partition_skeleton_finalize;
  gobject_class->get_property = udisks_partition_skeleton_get_property;
  gobject_class->set_property = udisks_partition_skeleton_set_property;
  gobject_class->notify       = udisks_partition_skeleton_notify;


  udisks_partition_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_partition_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_partition_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_partition_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_partition_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksPartitionSkeletonPrivate));
#endif
}

static void
udisks_partition_skeleton_iface_init (UDisksPartitionIface *iface)
{
  iface->get_number = udisks_partition_skeleton_get_number;
  iface->get_type_ = udisks_partition_skeleton_get_type_;
  iface->get_flags = udisks_partition_skeleton_get_flags;
  iface->get_offset = udisks_partition_skeleton_get_offset;
  iface->get_size = udisks_partition_skeleton_get_size;
  iface->get_name = udisks_partition_skeleton_get_name;
  iface->get_uuid = udisks_partition_skeleton_get_uuid;
  iface->get_table = udisks_partition_skeleton_get_table;
  iface->get_is_container = udisks_partition_skeleton_get_is_container;
  iface->get_is_contained = udisks_partition_skeleton_get_is_contained;
}

/**
 * udisks_partition_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Partition.top_of_page">org.freedesktop.UDisks2.Partition</link>.
 *
 * Returns: (transfer full) (type UDisksPartitionSkeleton): The skeleton object.
 */
UDisksPartition *
udisks_partition_skeleton_new (void)
{
  return UDISKS_PARTITION (g_object_new (UDISKS_TYPE_PARTITION_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Filesystem
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksFilesystem
 * @title: UDisksFilesystem
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Filesystem D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem.top_of_page">org.freedesktop.UDisks2.Filesystem</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Filesystem ---- */

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_set_label_IN_ARG_label =
{
  {
    -1,
    (gchar *) "label",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_set_label_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_method_info_set_label_IN_ARG_pointers[] =
{
  &_udisks_filesystem_method_info_set_label_IN_ARG_label.parent_struct,
  &_udisks_filesystem_method_info_set_label_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_method_info_set_label =
{
  {
    -1,
    (gchar *) "SetLabel",
    (GDBusArgInfo **) &_udisks_filesystem_method_info_set_label_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-label",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_set_uuid_IN_ARG_uuid =
{
  {
    -1,
    (gchar *) "uuid",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_set_uuid_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_method_info_set_uuid_IN_ARG_pointers[] =
{
  &_udisks_filesystem_method_info_set_uuid_IN_ARG_uuid.parent_struct,
  &_udisks_filesystem_method_info_set_uuid_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_method_info_set_uuid =
{
  {
    -1,
    (gchar *) "SetUUID",
    (GDBusArgInfo **) &_udisks_filesystem_method_info_set_uuid_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-uuid",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_mount_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_method_info_mount_IN_ARG_pointers[] =
{
  &_udisks_filesystem_method_info_mount_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_mount_OUT_ARG_mount_path =
{
  {
    -1,
    (gchar *) "mount_path",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_method_info_mount_OUT_ARG_pointers[] =
{
  &_udisks_filesystem_method_info_mount_OUT_ARG_mount_path.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_method_info_mount =
{
  {
    -1,
    (gchar *) "Mount",
    (GDBusArgInfo **) &_udisks_filesystem_method_info_mount_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_filesystem_method_info_mount_OUT_ARG_pointers,
    NULL
  },
  "handle-mount",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_unmount_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_method_info_unmount_IN_ARG_pointers[] =
{
  &_udisks_filesystem_method_info_unmount_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_method_info_unmount =
{
  {
    -1,
    (gchar *) "Unmount",
    (GDBusArgInfo **) &_udisks_filesystem_method_info_unmount_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-unmount",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_resize_IN_ARG_size =
{
  {
    -1,
    (gchar *) "size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_resize_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_method_info_resize_IN_ARG_pointers[] =
{
  &_udisks_filesystem_method_info_resize_IN_ARG_size.parent_struct,
  &_udisks_filesystem_method_info_resize_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_method_info_resize =
{
  {
    -1,
    (gchar *) "Resize",
    (GDBusArgInfo **) &_udisks_filesystem_method_info_resize_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-resize",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_check_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_method_info_check_IN_ARG_pointers[] =
{
  &_udisks_filesystem_method_info_check_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_check_OUT_ARG_consistent =
{
  {
    -1,
    (gchar *) "consistent",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_method_info_check_OUT_ARG_pointers[] =
{
  &_udisks_filesystem_method_info_check_OUT_ARG_consistent.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_method_info_check =
{
  {
    -1,
    (gchar *) "Check",
    (GDBusArgInfo **) &_udisks_filesystem_method_info_check_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_filesystem_method_info_check_OUT_ARG_pointers,
    NULL
  },
  "handle-check",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_repair_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_method_info_repair_IN_ARG_pointers[] =
{
  &_udisks_filesystem_method_info_repair_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_repair_OUT_ARG_repaired =
{
  {
    -1,
    (gchar *) "repaired",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_method_info_repair_OUT_ARG_pointers[] =
{
  &_udisks_filesystem_method_info_repair_OUT_ARG_repaired.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_method_info_repair =
{
  {
    -1,
    (gchar *) "Repair",
    (GDBusArgInfo **) &_udisks_filesystem_method_info_repair_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_filesystem_method_info_repair_OUT_ARG_pointers,
    NULL
  },
  "handle-repair",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_method_info_take_ownership_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_method_info_take_ownership_IN_ARG_pointers[] =
{
  &_udisks_filesystem_method_info_take_ownership_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_method_info_take_ownership =
{
  {
    -1,
    (gchar *) "TakeOwnership",
    (GDBusArgInfo **) &_udisks_filesystem_method_info_take_ownership_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-take-ownership",
  FALSE
};

static const GDBusMethodInfo * const _udisks_filesystem_method_info_pointers[] =
{
  &_udisks_filesystem_method_info_set_label.parent_struct,
  &_udisks_filesystem_method_info_set_uuid.parent_struct,
  &_udisks_filesystem_method_info_mount.parent_struct,
  &_udisks_filesystem_method_info_unmount.parent_struct,
  &_udisks_filesystem_method_info_resize.parent_struct,
  &_udisks_filesystem_method_info_check.parent_struct,
  &_udisks_filesystem_method_info_repair.parent_struct,
  &_udisks_filesystem_method_info_take_ownership.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_filesystem_property_info_mount_points =
{
  {
    -1,
    (gchar *) "MountPoints",
    (gchar *) "aay",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "mount-points",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_filesystem_property_info_size =
{
  {
    -1,
    (gchar *) "Size",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "size",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_filesystem_property_info_pointers[] =
{
  &_udisks_filesystem_property_info_mount_points.parent_struct,
  &_udisks_filesystem_property_info_size.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_filesystem_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Filesystem",
    (GDBusMethodInfo **) &_udisks_filesystem_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_filesystem_property_info_pointers,
    NULL
  },
  "filesystem",
};


/**
 * udisks_filesystem_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem.top_of_page">org.freedesktop.UDisks2.Filesystem</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_filesystem_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_filesystem_interface_info.parent_struct;
}

/**
 * udisks_filesystem_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksFilesystem interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_filesystem_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "mount-points");
  g_object_class_override_property (klass, property_id_begin++, "size");
  return property_id_begin - 1;
}


inline static void
udisks_filesystem_method_marshal_set_label (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_method_marshal_set_uuid (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_method_marshal_mount (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_method_marshal_unmount (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_method_marshal_resize (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT64_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_method_marshal_check (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_method_marshal_repair (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_method_marshal_take_ownership (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksFilesystem:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem.top_of_page">org.freedesktop.UDisks2.Filesystem</link>.
 */

/**
 * UDisksFilesystemIface:
 * @parent_iface: The parent interface.
 * @handle_check: Handler for the #UDisksFilesystem::handle-check signal.
 * @handle_mount: Handler for the #UDisksFilesystem::handle-mount signal.
 * @handle_repair: Handler for the #UDisksFilesystem::handle-repair signal.
 * @handle_set_label: Handler for the #UDisksFilesystem::handle-set-label signal.
 * @handle_take_ownership: Handler for the #UDisksFilesystem::handle-take-ownership signal.
 * @handle_unmount: Handler for the #UDisksFilesystem::handle-unmount signal.
 * @get_mount_points: Getter for the #UDisksFilesystem:mount-points property.
 * @get_size: Getter for the #UDisksFilesystem:size property.
 * @handle_resize: Handler for the #UDisksFilesystem::handle-resize signal.
 * @handle_set_uuid: Handler for the #UDisksFilesystem::handle-set-uuid signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem.top_of_page">org.freedesktop.UDisks2.Filesystem</link>.
 */

typedef UDisksFilesystemIface UDisksFilesystemInterface;
G_DEFINE_INTERFACE (UDisksFilesystem, udisks_filesystem, G_TYPE_OBJECT)

static void
udisks_filesystem_default_init (UDisksFilesystemIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksFilesystem::handle-set-label:
   * @object: A #UDisksFilesystem.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_label: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.SetLabel">SetLabel()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_complete_set_label() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-set-label",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemIface, handle_set_label),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_method_marshal_set_label,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksFilesystem::handle-set-uuid:
   * @object: A #UDisksFilesystem.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_uuid: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.SetUUID">SetUUID()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_complete_set_uuid() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.10.0
   */
  g_signal_new ("handle-set-uuid",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemIface, handle_set_uuid),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_method_marshal_set_uuid,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksFilesystem::handle-mount:
   * @object: A #UDisksFilesystem.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Mount">Mount()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_complete_mount() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-mount",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemIface, handle_mount),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_method_marshal_mount,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksFilesystem::handle-unmount:
   * @object: A #UDisksFilesystem.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Unmount">Unmount()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_complete_unmount() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-unmount",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemIface, handle_unmount),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_method_marshal_unmount,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksFilesystem::handle-resize:
   * @object: A #UDisksFilesystem.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_size: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Resize">Resize()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_complete_resize() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.7.2
   */
  g_signal_new ("handle-resize",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemIface, handle_resize),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_method_marshal_resize,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT64, G_TYPE_VARIANT);

  /**
   * UDisksFilesystem::handle-check:
   * @object: A #UDisksFilesystem.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Check">Check()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_complete_check() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-check",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemIface, handle_check),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_method_marshal_check,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksFilesystem::handle-repair:
   * @object: A #UDisksFilesystem.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Repair">Repair()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_complete_repair() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-repair",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemIface, handle_repair),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_method_marshal_repair,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksFilesystem::handle-take-ownership:
   * @object: A #UDisksFilesystem.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.TakeOwnership">TakeOwnership()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_complete_take_ownership() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-take-ownership",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemIface, handle_take_ownership),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_method_marshal_take_ownership,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksFilesystem:mount-points:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem.MountPoints">"MountPoints"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boxed ("mount-points", "MountPoints", "MountPoints", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksFilesystem:size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem.Size">"Size"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("size", "Size", "Size", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_filesystem_get_mount_points: (skip)
 * @object: A #UDisksFilesystem.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem.MountPoints">"MountPoints"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_filesystem_dup_mount_points() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *const *
udisks_filesystem_get_mount_points (UDisksFilesystem *object)
{
  g_return_val_if_fail (UDISKS_IS_FILESYSTEM (object), NULL);

  return UDISKS_FILESYSTEM_GET_IFACE (object)->get_mount_points (object);
}

/**
 * udisks_filesystem_dup_mount_points: (skip)
 * @object: A #UDisksFilesystem.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem.MountPoints">"MountPoints"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_strfreev().
 */
gchar **
udisks_filesystem_dup_mount_points (UDisksFilesystem *object)
{
  gchar **value;
  g_object_get (G_OBJECT (object), "mount-points", &value, NULL);
  return value;
}

/**
 * udisks_filesystem_set_mount_points: (skip)
 * @object: A #UDisksFilesystem.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem.MountPoints">"MountPoints"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_filesystem_set_mount_points (UDisksFilesystem *object, const gchar *const *value)
{
  g_object_set (G_OBJECT (object), "mount-points", value, NULL);
}

/**
 * udisks_filesystem_get_size: (skip)
 * @object: A #UDisksFilesystem.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem.Size">"Size"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_filesystem_get_size (UDisksFilesystem *object)
{
  g_return_val_if_fail (UDISKS_IS_FILESYSTEM (object), 0);

  return UDISKS_FILESYSTEM_GET_IFACE (object)->get_size (object);
}

/**
 * udisks_filesystem_set_size: (skip)
 * @object: A #UDisksFilesystem.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem.Size">"Size"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_filesystem_set_size (UDisksFilesystem *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "size", value, NULL);
}

/**
 * udisks_filesystem_call_set_label:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_label: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.SetLabel">SetLabel()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_call_set_label_finish() to get the result of the operation.
 *
 * See udisks_filesystem_call_set_label_sync() for the synchronous, blocking version of this method.
 */
void
udisks_filesystem_call_set_label (
    UDisksFilesystem *proxy,
    const gchar *arg_label,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetLabel",
    g_variant_new ("(s@a{sv})",
                   arg_label,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_call_set_label_finish:
 * @proxy: A #UDisksFilesystemProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_call_set_label().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_call_set_label().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_filesystem_call_set_label_finish (
    UDisksFilesystem *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_set_label_sync:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_label: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.SetLabel">SetLabel()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_call_set_label() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_filesystem_call_set_label_sync (
    UDisksFilesystem *proxy,
    const gchar *arg_label,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetLabel",
    g_variant_new ("(s@a{sv})",
                   arg_label,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_set_uuid:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_uuid: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.SetUUID">SetUUID()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_call_set_uuid_finish() to get the result of the operation.
 *
 * See udisks_filesystem_call_set_uuid_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.10.0
 */
void
udisks_filesystem_call_set_uuid (
    UDisksFilesystem *proxy,
    const gchar *arg_uuid,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetUUID",
    g_variant_new ("(s@a{sv})",
                   arg_uuid,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_call_set_uuid_finish:
 * @proxy: A #UDisksFilesystemProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_call_set_uuid().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_call_set_uuid().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_filesystem_call_set_uuid_finish (
    UDisksFilesystem *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_set_uuid_sync:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_uuid: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.SetUUID">SetUUID()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_call_set_uuid() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_filesystem_call_set_uuid_sync (
    UDisksFilesystem *proxy,
    const gchar *arg_uuid,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetUUID",
    g_variant_new ("(s@a{sv})",
                   arg_uuid,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_mount:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Mount">Mount()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_call_mount_finish() to get the result of the operation.
 *
 * See udisks_filesystem_call_mount_sync() for the synchronous, blocking version of this method.
 */
void
udisks_filesystem_call_mount (
    UDisksFilesystem *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Mount",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_call_mount_finish:
 * @proxy: A #UDisksFilesystemProxy.
 * @out_mount_path: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_call_mount().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_call_mount().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_filesystem_call_mount_finish (
    UDisksFilesystem *proxy,
    gchar ** out_mount_path,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(s)",
                 out_mount_path);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_mount_sync:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @out_mount_path: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Mount">Mount()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_call_mount() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_filesystem_call_mount_sync (
    UDisksFilesystem *proxy,
    GVariant *arg_options,
    gchar ** out_mount_path,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Mount",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(s)",
                 out_mount_path);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_unmount:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Unmount">Unmount()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_call_unmount_finish() to get the result of the operation.
 *
 * See udisks_filesystem_call_unmount_sync() for the synchronous, blocking version of this method.
 */
void
udisks_filesystem_call_unmount (
    UDisksFilesystem *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Unmount",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_call_unmount_finish:
 * @proxy: A #UDisksFilesystemProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_call_unmount().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_call_unmount().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_filesystem_call_unmount_finish (
    UDisksFilesystem *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_unmount_sync:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Unmount">Unmount()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_call_unmount() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_filesystem_call_unmount_sync (
    UDisksFilesystem *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Unmount",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_resize:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Resize">Resize()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_call_resize_finish() to get the result of the operation.
 *
 * See udisks_filesystem_call_resize_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.7.2
 */
void
udisks_filesystem_call_resize (
    UDisksFilesystem *proxy,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Resize",
    g_variant_new ("(t@a{sv})",
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_call_resize_finish:
 * @proxy: A #UDisksFilesystemProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_call_resize().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_call_resize().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.2
 */
gboolean
udisks_filesystem_call_resize_finish (
    UDisksFilesystem *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_resize_sync:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Resize">Resize()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_call_resize() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.7.2
 */
gboolean
udisks_filesystem_call_resize_sync (
    UDisksFilesystem *proxy,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Resize",
    g_variant_new ("(t@a{sv})",
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_check:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Check">Check()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_call_check_finish() to get the result of the operation.
 *
 * See udisks_filesystem_call_check_sync() for the synchronous, blocking version of this method.
 */
void
udisks_filesystem_call_check (
    UDisksFilesystem *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Check",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_call_check_finish:
 * @proxy: A #UDisksFilesystemProxy.
 * @out_consistent: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_call_check().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_call_check().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_filesystem_call_check_finish (
    UDisksFilesystem *proxy,
    gboolean* out_consistent,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(b)",
                 out_consistent);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_check_sync:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @out_consistent: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Check">Check()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_call_check() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_filesystem_call_check_sync (
    UDisksFilesystem *proxy,
    GVariant *arg_options,
    gboolean* out_consistent,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Check",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(b)",
                 out_consistent);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_repair:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Repair">Repair()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_call_repair_finish() to get the result of the operation.
 *
 * See udisks_filesystem_call_repair_sync() for the synchronous, blocking version of this method.
 */
void
udisks_filesystem_call_repair (
    UDisksFilesystem *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Repair",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_call_repair_finish:
 * @proxy: A #UDisksFilesystemProxy.
 * @out_repaired: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_call_repair().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_call_repair().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_filesystem_call_repair_finish (
    UDisksFilesystem *proxy,
    gboolean* out_repaired,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(b)",
                 out_repaired);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_repair_sync:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @out_repaired: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Repair">Repair()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_call_repair() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_filesystem_call_repair_sync (
    UDisksFilesystem *proxy,
    GVariant *arg_options,
    gboolean* out_repaired,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Repair",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(b)",
                 out_repaired);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_take_ownership:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.TakeOwnership">TakeOwnership()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_call_take_ownership_finish() to get the result of the operation.
 *
 * See udisks_filesystem_call_take_ownership_sync() for the synchronous, blocking version of this method.
 */
void
udisks_filesystem_call_take_ownership (
    UDisksFilesystem *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "TakeOwnership",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_call_take_ownership_finish:
 * @proxy: A #UDisksFilesystemProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_call_take_ownership().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_call_take_ownership().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_filesystem_call_take_ownership_finish (
    UDisksFilesystem *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_call_take_ownership_sync:
 * @proxy: A #UDisksFilesystemProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.TakeOwnership">TakeOwnership()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_call_take_ownership() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_filesystem_call_take_ownership_sync (
    UDisksFilesystem *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "TakeOwnership",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_complete_set_label:
 * @object: A #UDisksFilesystem.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.SetLabel">SetLabel()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_filesystem_complete_set_label (
    UDisksFilesystem *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_filesystem_complete_set_uuid:
 * @object: A #UDisksFilesystem.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.SetUUID">SetUUID()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.10.0
 */
void
udisks_filesystem_complete_set_uuid (
    UDisksFilesystem *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_filesystem_complete_mount:
 * @object: A #UDisksFilesystem.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @mount_path: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Mount">Mount()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_filesystem_complete_mount (
    UDisksFilesystem *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *mount_path)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(s)",
                   mount_path));
}

/**
 * udisks_filesystem_complete_unmount:
 * @object: A #UDisksFilesystem.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Unmount">Unmount()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_filesystem_complete_unmount (
    UDisksFilesystem *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_filesystem_complete_resize:
 * @object: A #UDisksFilesystem.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Resize">Resize()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.7.2
 */
void
udisks_filesystem_complete_resize (
    UDisksFilesystem *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_filesystem_complete_check:
 * @object: A #UDisksFilesystem.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @consistent: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Check">Check()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_filesystem_complete_check (
    UDisksFilesystem *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    gboolean consistent)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(b)",
                   consistent));
}

/**
 * udisks_filesystem_complete_repair:
 * @object: A #UDisksFilesystem.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @repaired: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.Repair">Repair()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_filesystem_complete_repair (
    UDisksFilesystem *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    gboolean repaired)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(b)",
                   repaired));
}

/**
 * udisks_filesystem_complete_take_ownership:
 * @object: A #UDisksFilesystem.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem.TakeOwnership">TakeOwnership()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_filesystem_complete_take_ownership (
    UDisksFilesystem *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksFilesystemProxy:
 *
 * The #UDisksFilesystemProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksFilesystemProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksFilesystemProxy.
 */

struct _UDisksFilesystemProxyPrivate
{
  GData *qdata;
};

static void udisks_filesystem_proxy_iface_init (UDisksFilesystemIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksFilesystemProxy, udisks_filesystem_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksFilesystemProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_FILESYSTEM, udisks_filesystem_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksFilesystemProxy, udisks_filesystem_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_FILESYSTEM, udisks_filesystem_proxy_iface_init))

#endif
static void
udisks_filesystem_proxy_finalize (GObject *object)
{
  UDisksFilesystemProxy *proxy = UDISKS_FILESYSTEM_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_filesystem_proxy_parent_class)->finalize (object);
}

static void
udisks_filesystem_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 2);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_filesystem_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_filesystem_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.Filesystem: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_filesystem_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 2);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_filesystem_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.Filesystem", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_filesystem_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_filesystem_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_filesystem_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_FILESYSTEM);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_FILESYSTEM);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_filesystem_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksFilesystemProxy *proxy = UDISKS_FILESYSTEM_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_filesystem_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_filesystem_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *const *
udisks_filesystem_proxy_get_mount_points (UDisksFilesystem *object)
{
  UDisksFilesystemProxy *proxy = UDISKS_FILESYSTEM_PROXY (object);
  GVariant *variant;
  const gchar *const *value = NULL;
  value = g_datalist_get_data (&proxy->priv->qdata, "MountPoints");
  if (value != NULL)
    return value;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "MountPoints");
  if (variant != NULL)
    {
      value = g_variant_get_bytestring_array (variant, NULL);
      g_datalist_set_data_full (&proxy->priv->qdata, "MountPoints", (gpointer) value, g_free);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_filesystem_proxy_get_size (UDisksFilesystem *object)
{
  UDisksFilesystemProxy *proxy = UDISKS_FILESYSTEM_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Size");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_filesystem_proxy_init (UDisksFilesystemProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_filesystem_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_FILESYSTEM_PROXY, UDisksFilesystemProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_filesystem_interface_info ());
}

static void
udisks_filesystem_proxy_class_init (UDisksFilesystemProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_filesystem_proxy_finalize;
  gobject_class->get_property = udisks_filesystem_proxy_get_property;
  gobject_class->set_property = udisks_filesystem_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_filesystem_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_filesystem_proxy_g_properties_changed;

  udisks_filesystem_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksFilesystemProxyPrivate));
#endif
}

static void
udisks_filesystem_proxy_iface_init (UDisksFilesystemIface *iface)
{
  iface->get_mount_points = udisks_filesystem_proxy_get_mount_points;
  iface->get_size = udisks_filesystem_proxy_get_size;
}

/**
 * udisks_filesystem_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem.top_of_page">org.freedesktop.UDisks2.Filesystem</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_filesystem_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_filesystem_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_FILESYSTEM_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Filesystem", NULL);
}

/**
 * udisks_filesystem_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_filesystem_proxy_new().
 *
 * Returns: (transfer full) (type UDisksFilesystemProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksFilesystem *
udisks_filesystem_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_FILESYSTEM (ret);
  else
    return NULL;
}

/**
 * udisks_filesystem_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem.top_of_page">org.freedesktop.UDisks2.Filesystem</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksFilesystemProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksFilesystem *
udisks_filesystem_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_FILESYSTEM_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Filesystem", NULL);
  if (ret != NULL)
    return UDISKS_FILESYSTEM (ret);
  else
    return NULL;
}


/**
 * udisks_filesystem_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_filesystem_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_filesystem_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_filesystem_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_FILESYSTEM_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Filesystem", NULL);
}

/**
 * udisks_filesystem_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_filesystem_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksFilesystemProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksFilesystem *
udisks_filesystem_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_FILESYSTEM (ret);
  else
    return NULL;
}

/**
 * udisks_filesystem_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_filesystem_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksFilesystemProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksFilesystem *
udisks_filesystem_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_FILESYSTEM_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Filesystem", NULL);
  if (ret != NULL)
    return UDISKS_FILESYSTEM (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksFilesystemSkeleton:
 *
 * The #UDisksFilesystemSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksFilesystemSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksFilesystemSkeleton.
 */

struct _UDisksFilesystemSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_filesystem_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksFilesystemSkeleton *skeleton = UDISKS_FILESYSTEM_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_FILESYSTEM);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_FILESYSTEM);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_filesystem_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksFilesystemSkeleton *skeleton = UDISKS_FILESYSTEM_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_filesystem_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_filesystem_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksFilesystemSkeleton *skeleton = UDISKS_FILESYSTEM_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_filesystem_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_filesystem_skeleton_vtable =
{
  _udisks_filesystem_skeleton_handle_method_call,
  _udisks_filesystem_skeleton_handle_get_property,
  _udisks_filesystem_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_filesystem_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_filesystem_interface_info ();
}

static GDBusInterfaceVTable *
udisks_filesystem_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_filesystem_skeleton_vtable;
}

static GVariant *
udisks_filesystem_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksFilesystemSkeleton *skeleton = UDISKS_FILESYSTEM_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_filesystem_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_filesystem_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_filesystem_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_filesystem_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Filesystem", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_filesystem_emit_changed (gpointer user_data);

static void
udisks_filesystem_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksFilesystemSkeleton *skeleton = UDISKS_FILESYSTEM_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_filesystem_emit_changed (skeleton);
}

static void udisks_filesystem_skeleton_iface_init (UDisksFilesystemIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksFilesystemSkeleton, udisks_filesystem_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksFilesystemSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_FILESYSTEM, udisks_filesystem_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksFilesystemSkeleton, udisks_filesystem_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_FILESYSTEM, udisks_filesystem_skeleton_iface_init))

#endif
static void
udisks_filesystem_skeleton_finalize (GObject *object)
{
  UDisksFilesystemSkeleton *skeleton = UDISKS_FILESYSTEM_SKELETON (object);
  guint n;
  for (n = 0; n < 2; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_filesystem_skeleton_parent_class)->finalize (object);
}

static void
udisks_filesystem_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksFilesystemSkeleton *skeleton = UDISKS_FILESYSTEM_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 2);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_filesystem_emit_changed (gpointer user_data)
{
  UDisksFilesystemSkeleton *skeleton = UDISKS_FILESYSTEM_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.Filesystem",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_filesystem_schedule_emit_changed (UDisksFilesystemSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_filesystem_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksFilesystemSkeleton *skeleton = UDISKS_FILESYSTEM_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_filesystem_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_filesystem_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_filesystem_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksFilesystemSkeleton *skeleton = UDISKS_FILESYSTEM_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 2);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_filesystem_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_filesystem_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_filesystem_skeleton_init (UDisksFilesystemSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_filesystem_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_FILESYSTEM_SKELETON, UDisksFilesystemSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 2);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRV);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_UINT64);
}

static const gchar *const *
udisks_filesystem_skeleton_get_mount_points (UDisksFilesystem *object)
{
  UDisksFilesystemSkeleton *skeleton = UDISKS_FILESYSTEM_SKELETON (object);
  const gchar *const *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boxed (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_filesystem_skeleton_get_size (UDisksFilesystem *object)
{
  UDisksFilesystemSkeleton *skeleton = UDISKS_FILESYSTEM_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_filesystem_skeleton_class_init (UDisksFilesystemSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_filesystem_skeleton_finalize;
  gobject_class->get_property = udisks_filesystem_skeleton_get_property;
  gobject_class->set_property = udisks_filesystem_skeleton_set_property;
  gobject_class->notify       = udisks_filesystem_skeleton_notify;


  udisks_filesystem_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_filesystem_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_filesystem_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_filesystem_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_filesystem_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksFilesystemSkeletonPrivate));
#endif
}

static void
udisks_filesystem_skeleton_iface_init (UDisksFilesystemIface *iface)
{
  iface->get_mount_points = udisks_filesystem_skeleton_get_mount_points;
  iface->get_size = udisks_filesystem_skeleton_get_size;
}

/**
 * udisks_filesystem_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem.top_of_page">org.freedesktop.UDisks2.Filesystem</link>.
 *
 * Returns: (transfer full) (type UDisksFilesystemSkeleton): The skeleton object.
 */
UDisksFilesystem *
udisks_filesystem_skeleton_new (void)
{
  return UDISKS_FILESYSTEM (g_object_new (UDISKS_TYPE_FILESYSTEM_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Swapspace
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksSwapspace
 * @title: UDisksSwapspace
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Swapspace D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Swapspace.top_of_page">org.freedesktop.UDisks2.Swapspace</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Swapspace ---- */

static const _ExtendedGDBusArgInfo _udisks_swapspace_method_info_start_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_swapspace_method_info_start_IN_ARG_pointers[] =
{
  &_udisks_swapspace_method_info_start_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_swapspace_method_info_start =
{
  {
    -1,
    (gchar *) "Start",
    (GDBusArgInfo **) &_udisks_swapspace_method_info_start_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-start",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_swapspace_method_info_stop_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_swapspace_method_info_stop_IN_ARG_pointers[] =
{
  &_udisks_swapspace_method_info_stop_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_swapspace_method_info_stop =
{
  {
    -1,
    (gchar *) "Stop",
    (GDBusArgInfo **) &_udisks_swapspace_method_info_stop_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-stop",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_swapspace_method_info_set_label_IN_ARG_label =
{
  {
    -1,
    (gchar *) "label",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_swapspace_method_info_set_label_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_swapspace_method_info_set_label_IN_ARG_pointers[] =
{
  &_udisks_swapspace_method_info_set_label_IN_ARG_label.parent_struct,
  &_udisks_swapspace_method_info_set_label_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_swapspace_method_info_set_label =
{
  {
    -1,
    (gchar *) "SetLabel",
    (GDBusArgInfo **) &_udisks_swapspace_method_info_set_label_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-label",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_swapspace_method_info_set_uuid_IN_ARG_uuid =
{
  {
    -1,
    (gchar *) "uuid",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_swapspace_method_info_set_uuid_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_swapspace_method_info_set_uuid_IN_ARG_pointers[] =
{
  &_udisks_swapspace_method_info_set_uuid_IN_ARG_uuid.parent_struct,
  &_udisks_swapspace_method_info_set_uuid_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_swapspace_method_info_set_uuid =
{
  {
    -1,
    (gchar *) "SetUUID",
    (GDBusArgInfo **) &_udisks_swapspace_method_info_set_uuid_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-uuid",
  FALSE
};

static const GDBusMethodInfo * const _udisks_swapspace_method_info_pointers[] =
{
  &_udisks_swapspace_method_info_start.parent_struct,
  &_udisks_swapspace_method_info_stop.parent_struct,
  &_udisks_swapspace_method_info_set_label.parent_struct,
  &_udisks_swapspace_method_info_set_uuid.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_swapspace_property_info_active =
{
  {
    -1,
    (gchar *) "Active",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "active",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_swapspace_property_info_pointers[] =
{
  &_udisks_swapspace_property_info_active.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_swapspace_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Swapspace",
    (GDBusMethodInfo **) &_udisks_swapspace_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_swapspace_property_info_pointers,
    NULL
  },
  "swapspace",
};


/**
 * udisks_swapspace_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Swapspace.top_of_page">org.freedesktop.UDisks2.Swapspace</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_swapspace_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_swapspace_interface_info.parent_struct;
}

/**
 * udisks_swapspace_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksSwapspace interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_swapspace_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "active");
  return property_id_begin - 1;
}


inline static void
udisks_swapspace_method_marshal_start (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_swapspace_method_marshal_stop (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_swapspace_method_marshal_set_label (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_swapspace_method_marshal_set_uuid (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksSwapspace:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Swapspace.top_of_page">org.freedesktop.UDisks2.Swapspace</link>.
 */

/**
 * UDisksSwapspaceIface:
 * @parent_iface: The parent interface.
 * @handle_set_label: Handler for the #UDisksSwapspace::handle-set-label signal.
 * @handle_start: Handler for the #UDisksSwapspace::handle-start signal.
 * @handle_stop: Handler for the #UDisksSwapspace::handle-stop signal.
 * @get_active: Getter for the #UDisksSwapspace:active property.
 * @handle_set_uuid: Handler for the #UDisksSwapspace::handle-set-uuid signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Swapspace.top_of_page">org.freedesktop.UDisks2.Swapspace</link>.
 */

typedef UDisksSwapspaceIface UDisksSwapspaceInterface;
G_DEFINE_INTERFACE (UDisksSwapspace, udisks_swapspace, G_TYPE_OBJECT)

static void
udisks_swapspace_default_init (UDisksSwapspaceIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksSwapspace::handle-start:
   * @object: A #UDisksSwapspace.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.Start">Start()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_swapspace_complete_start() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-start",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksSwapspaceIface, handle_start),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_swapspace_method_marshal_start,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksSwapspace::handle-stop:
   * @object: A #UDisksSwapspace.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.Stop">Stop()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_swapspace_complete_stop() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-stop",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksSwapspaceIface, handle_stop),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_swapspace_method_marshal_stop,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksSwapspace::handle-set-label:
   * @object: A #UDisksSwapspace.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_label: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.SetLabel">SetLabel()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_swapspace_complete_set_label() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-set-label",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksSwapspaceIface, handle_set_label),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_swapspace_method_marshal_set_label,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksSwapspace::handle-set-uuid:
   * @object: A #UDisksSwapspace.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_uuid: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.SetUUID">SetUUID()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_swapspace_complete_set_uuid() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.10.0
   */
  g_signal_new ("handle-set-uuid",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksSwapspaceIface, handle_set_uuid),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_swapspace_method_marshal_set_uuid,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksSwapspace:active:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Swapspace.Active">"Active"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("active", "Active", "Active", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_swapspace_get_active: (skip)
 * @object: A #UDisksSwapspace.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Swapspace.Active">"Active"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_swapspace_get_active (UDisksSwapspace *object)
{
  g_return_val_if_fail (UDISKS_IS_SWAPSPACE (object), FALSE);

  return UDISKS_SWAPSPACE_GET_IFACE (object)->get_active (object);
}

/**
 * udisks_swapspace_set_active: (skip)
 * @object: A #UDisksSwapspace.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Swapspace.Active">"Active"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_swapspace_set_active (UDisksSwapspace *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "active", value, NULL);
}

/**
 * udisks_swapspace_call_start:
 * @proxy: A #UDisksSwapspaceProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.Start">Start()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_swapspace_call_start_finish() to get the result of the operation.
 *
 * See udisks_swapspace_call_start_sync() for the synchronous, blocking version of this method.
 */
void
udisks_swapspace_call_start (
    UDisksSwapspace *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Start",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_swapspace_call_start_finish:
 * @proxy: A #UDisksSwapspaceProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_swapspace_call_start().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_swapspace_call_start().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_swapspace_call_start_finish (
    UDisksSwapspace *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_swapspace_call_start_sync:
 * @proxy: A #UDisksSwapspaceProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.Start">Start()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_swapspace_call_start() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_swapspace_call_start_sync (
    UDisksSwapspace *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Start",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_swapspace_call_stop:
 * @proxy: A #UDisksSwapspaceProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.Stop">Stop()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_swapspace_call_stop_finish() to get the result of the operation.
 *
 * See udisks_swapspace_call_stop_sync() for the synchronous, blocking version of this method.
 */
void
udisks_swapspace_call_stop (
    UDisksSwapspace *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Stop",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_swapspace_call_stop_finish:
 * @proxy: A #UDisksSwapspaceProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_swapspace_call_stop().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_swapspace_call_stop().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_swapspace_call_stop_finish (
    UDisksSwapspace *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_swapspace_call_stop_sync:
 * @proxy: A #UDisksSwapspaceProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.Stop">Stop()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_swapspace_call_stop() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_swapspace_call_stop_sync (
    UDisksSwapspace *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Stop",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_swapspace_call_set_label:
 * @proxy: A #UDisksSwapspaceProxy.
 * @arg_label: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.SetLabel">SetLabel()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_swapspace_call_set_label_finish() to get the result of the operation.
 *
 * See udisks_swapspace_call_set_label_sync() for the synchronous, blocking version of this method.
 */
void
udisks_swapspace_call_set_label (
    UDisksSwapspace *proxy,
    const gchar *arg_label,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetLabel",
    g_variant_new ("(s@a{sv})",
                   arg_label,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_swapspace_call_set_label_finish:
 * @proxy: A #UDisksSwapspaceProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_swapspace_call_set_label().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_swapspace_call_set_label().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_swapspace_call_set_label_finish (
    UDisksSwapspace *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_swapspace_call_set_label_sync:
 * @proxy: A #UDisksSwapspaceProxy.
 * @arg_label: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.SetLabel">SetLabel()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_swapspace_call_set_label() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_swapspace_call_set_label_sync (
    UDisksSwapspace *proxy,
    const gchar *arg_label,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetLabel",
    g_variant_new ("(s@a{sv})",
                   arg_label,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_swapspace_call_set_uuid:
 * @proxy: A #UDisksSwapspaceProxy.
 * @arg_uuid: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.SetUUID">SetUUID()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_swapspace_call_set_uuid_finish() to get the result of the operation.
 *
 * See udisks_swapspace_call_set_uuid_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.10.0
 */
void
udisks_swapspace_call_set_uuid (
    UDisksSwapspace *proxy,
    const gchar *arg_uuid,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetUUID",
    g_variant_new ("(s@a{sv})",
                   arg_uuid,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_swapspace_call_set_uuid_finish:
 * @proxy: A #UDisksSwapspaceProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_swapspace_call_set_uuid().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_swapspace_call_set_uuid().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_swapspace_call_set_uuid_finish (
    UDisksSwapspace *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_swapspace_call_set_uuid_sync:
 * @proxy: A #UDisksSwapspaceProxy.
 * @arg_uuid: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.SetUUID">SetUUID()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_swapspace_call_set_uuid() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.10.0
 */
gboolean
udisks_swapspace_call_set_uuid_sync (
    UDisksSwapspace *proxy,
    const gchar *arg_uuid,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetUUID",
    g_variant_new ("(s@a{sv})",
                   arg_uuid,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_swapspace_complete_start:
 * @object: A #UDisksSwapspace.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.Start">Start()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_swapspace_complete_start (
    UDisksSwapspace *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_swapspace_complete_stop:
 * @object: A #UDisksSwapspace.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.Stop">Stop()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_swapspace_complete_stop (
    UDisksSwapspace *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_swapspace_complete_set_label:
 * @object: A #UDisksSwapspace.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.SetLabel">SetLabel()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_swapspace_complete_set_label (
    UDisksSwapspace *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_swapspace_complete_set_uuid:
 * @object: A #UDisksSwapspace.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Swapspace.SetUUID">SetUUID()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.10.0
 */
void
udisks_swapspace_complete_set_uuid (
    UDisksSwapspace *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksSwapspaceProxy:
 *
 * The #UDisksSwapspaceProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksSwapspaceProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksSwapspaceProxy.
 */

struct _UDisksSwapspaceProxyPrivate
{
  GData *qdata;
};

static void udisks_swapspace_proxy_iface_init (UDisksSwapspaceIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksSwapspaceProxy, udisks_swapspace_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksSwapspaceProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_SWAPSPACE, udisks_swapspace_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksSwapspaceProxy, udisks_swapspace_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_SWAPSPACE, udisks_swapspace_proxy_iface_init))

#endif
static void
udisks_swapspace_proxy_finalize (GObject *object)
{
  UDisksSwapspaceProxy *proxy = UDISKS_SWAPSPACE_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_swapspace_proxy_parent_class)->finalize (object);
}

static void
udisks_swapspace_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 1);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_swapspace_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_swapspace_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.Swapspace: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_swapspace_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 1);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_swapspace_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.Swapspace", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_swapspace_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_swapspace_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_swapspace_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_SWAPSPACE);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_SWAPSPACE);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_swapspace_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksSwapspaceProxy *proxy = UDISKS_SWAPSPACE_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_swapspace_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_swapspace_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static gboolean 
udisks_swapspace_proxy_get_active (UDisksSwapspace *object)
{
  UDisksSwapspaceProxy *proxy = UDISKS_SWAPSPACE_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Active");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_swapspace_proxy_init (UDisksSwapspaceProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_swapspace_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_SWAPSPACE_PROXY, UDisksSwapspaceProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_swapspace_interface_info ());
}

static void
udisks_swapspace_proxy_class_init (UDisksSwapspaceProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_swapspace_proxy_finalize;
  gobject_class->get_property = udisks_swapspace_proxy_get_property;
  gobject_class->set_property = udisks_swapspace_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_swapspace_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_swapspace_proxy_g_properties_changed;

  udisks_swapspace_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksSwapspaceProxyPrivate));
#endif
}

static void
udisks_swapspace_proxy_iface_init (UDisksSwapspaceIface *iface)
{
  iface->get_active = udisks_swapspace_proxy_get_active;
}

/**
 * udisks_swapspace_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Swapspace.top_of_page">org.freedesktop.UDisks2.Swapspace</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_swapspace_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_swapspace_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_swapspace_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_SWAPSPACE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Swapspace", NULL);
}

/**
 * udisks_swapspace_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_swapspace_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_swapspace_proxy_new().
 *
 * Returns: (transfer full) (type UDisksSwapspaceProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksSwapspace *
udisks_swapspace_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_SWAPSPACE (ret);
  else
    return NULL;
}

/**
 * udisks_swapspace_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Swapspace.top_of_page">org.freedesktop.UDisks2.Swapspace</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_swapspace_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksSwapspaceProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksSwapspace *
udisks_swapspace_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_SWAPSPACE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Swapspace", NULL);
  if (ret != NULL)
    return UDISKS_SWAPSPACE (ret);
  else
    return NULL;
}


/**
 * udisks_swapspace_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_swapspace_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_swapspace_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_swapspace_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_swapspace_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_SWAPSPACE_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Swapspace", NULL);
}

/**
 * udisks_swapspace_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_swapspace_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_swapspace_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksSwapspaceProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksSwapspace *
udisks_swapspace_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_SWAPSPACE (ret);
  else
    return NULL;
}

/**
 * udisks_swapspace_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_swapspace_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_swapspace_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksSwapspaceProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksSwapspace *
udisks_swapspace_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_SWAPSPACE_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Swapspace", NULL);
  if (ret != NULL)
    return UDISKS_SWAPSPACE (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksSwapspaceSkeleton:
 *
 * The #UDisksSwapspaceSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksSwapspaceSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksSwapspaceSkeleton.
 */

struct _UDisksSwapspaceSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_swapspace_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksSwapspaceSkeleton *skeleton = UDISKS_SWAPSPACE_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_SWAPSPACE);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_SWAPSPACE);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_swapspace_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksSwapspaceSkeleton *skeleton = UDISKS_SWAPSPACE_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_swapspace_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_swapspace_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksSwapspaceSkeleton *skeleton = UDISKS_SWAPSPACE_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_swapspace_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_swapspace_skeleton_vtable =
{
  _udisks_swapspace_skeleton_handle_method_call,
  _udisks_swapspace_skeleton_handle_get_property,
  _udisks_swapspace_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_swapspace_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_swapspace_interface_info ();
}

static GDBusInterfaceVTable *
udisks_swapspace_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_swapspace_skeleton_vtable;
}

static GVariant *
udisks_swapspace_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksSwapspaceSkeleton *skeleton = UDISKS_SWAPSPACE_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_swapspace_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_swapspace_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_swapspace_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_swapspace_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Swapspace", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_swapspace_emit_changed (gpointer user_data);

static void
udisks_swapspace_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksSwapspaceSkeleton *skeleton = UDISKS_SWAPSPACE_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_swapspace_emit_changed (skeleton);
}

static void udisks_swapspace_skeleton_iface_init (UDisksSwapspaceIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksSwapspaceSkeleton, udisks_swapspace_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksSwapspaceSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_SWAPSPACE, udisks_swapspace_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksSwapspaceSkeleton, udisks_swapspace_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_SWAPSPACE, udisks_swapspace_skeleton_iface_init))

#endif
static void
udisks_swapspace_skeleton_finalize (GObject *object)
{
  UDisksSwapspaceSkeleton *skeleton = UDISKS_SWAPSPACE_SKELETON (object);
  guint n;
  for (n = 0; n < 1; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_swapspace_skeleton_parent_class)->finalize (object);
}

static void
udisks_swapspace_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksSwapspaceSkeleton *skeleton = UDISKS_SWAPSPACE_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 1);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_swapspace_emit_changed (gpointer user_data)
{
  UDisksSwapspaceSkeleton *skeleton = UDISKS_SWAPSPACE_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.Swapspace",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_swapspace_schedule_emit_changed (UDisksSwapspaceSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_swapspace_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksSwapspaceSkeleton *skeleton = UDISKS_SWAPSPACE_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_swapspace_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_swapspace_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_swapspace_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksSwapspaceSkeleton *skeleton = UDISKS_SWAPSPACE_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 1);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_swapspace_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_swapspace_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_swapspace_skeleton_init (UDisksSwapspaceSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_swapspace_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_SWAPSPACE_SKELETON, UDisksSwapspaceSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 1);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_BOOLEAN);
}

static gboolean 
udisks_swapspace_skeleton_get_active (UDisksSwapspace *object)
{
  UDisksSwapspaceSkeleton *skeleton = UDISKS_SWAPSPACE_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_swapspace_skeleton_class_init (UDisksSwapspaceSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_swapspace_skeleton_finalize;
  gobject_class->get_property = udisks_swapspace_skeleton_get_property;
  gobject_class->set_property = udisks_swapspace_skeleton_set_property;
  gobject_class->notify       = udisks_swapspace_skeleton_notify;


  udisks_swapspace_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_swapspace_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_swapspace_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_swapspace_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_swapspace_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksSwapspaceSkeletonPrivate));
#endif
}

static void
udisks_swapspace_skeleton_iface_init (UDisksSwapspaceIface *iface)
{
  iface->get_active = udisks_swapspace_skeleton_get_active;
}

/**
 * udisks_swapspace_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Swapspace.top_of_page">org.freedesktop.UDisks2.Swapspace</link>.
 *
 * Returns: (transfer full) (type UDisksSwapspaceSkeleton): The skeleton object.
 */
UDisksSwapspace *
udisks_swapspace_skeleton_new (void)
{
  return UDISKS_SWAPSPACE (g_object_new (UDISKS_TYPE_SWAPSPACE_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Encrypted
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksEncrypted
 * @title: UDisksEncrypted
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Encrypted D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Encrypted.top_of_page">org.freedesktop.UDisks2.Encrypted</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Encrypted ---- */

static const _ExtendedGDBusArgInfo _udisks_encrypted_method_info_unlock_IN_ARG_passphrase =
{
  {
    -1,
    (gchar *) "passphrase",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_encrypted_method_info_unlock_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_encrypted_method_info_unlock_IN_ARG_pointers[] =
{
  &_udisks_encrypted_method_info_unlock_IN_ARG_passphrase.parent_struct,
  &_udisks_encrypted_method_info_unlock_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_encrypted_method_info_unlock_OUT_ARG_cleartext_device =
{
  {
    -1,
    (gchar *) "cleartext_device",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_encrypted_method_info_unlock_OUT_ARG_pointers[] =
{
  &_udisks_encrypted_method_info_unlock_OUT_ARG_cleartext_device.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_encrypted_method_info_unlock =
{
  {
    -1,
    (gchar *) "Unlock",
    (GDBusArgInfo **) &_udisks_encrypted_method_info_unlock_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_encrypted_method_info_unlock_OUT_ARG_pointers,
    NULL
  },
  "handle-unlock",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_encrypted_method_info_lock_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_encrypted_method_info_lock_IN_ARG_pointers[] =
{
  &_udisks_encrypted_method_info_lock_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_encrypted_method_info_lock =
{
  {
    -1,
    (gchar *) "Lock",
    (GDBusArgInfo **) &_udisks_encrypted_method_info_lock_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-lock",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_encrypted_method_info_change_passphrase_IN_ARG_passphrase =
{
  {
    -1,
    (gchar *) "passphrase",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_encrypted_method_info_change_passphrase_IN_ARG_new_passphrase =
{
  {
    -1,
    (gchar *) "new_passphrase",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_encrypted_method_info_change_passphrase_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_encrypted_method_info_change_passphrase_IN_ARG_pointers[] =
{
  &_udisks_encrypted_method_info_change_passphrase_IN_ARG_passphrase.parent_struct,
  &_udisks_encrypted_method_info_change_passphrase_IN_ARG_new_passphrase.parent_struct,
  &_udisks_encrypted_method_info_change_passphrase_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_encrypted_method_info_change_passphrase =
{
  {
    -1,
    (gchar *) "ChangePassphrase",
    (GDBusArgInfo **) &_udisks_encrypted_method_info_change_passphrase_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-change-passphrase",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_encrypted_method_info_resize_IN_ARG_size =
{
  {
    -1,
    (gchar *) "size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_encrypted_method_info_resize_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_encrypted_method_info_resize_IN_ARG_pointers[] =
{
  &_udisks_encrypted_method_info_resize_IN_ARG_size.parent_struct,
  &_udisks_encrypted_method_info_resize_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_encrypted_method_info_resize =
{
  {
    -1,
    (gchar *) "Resize",
    (GDBusArgInfo **) &_udisks_encrypted_method_info_resize_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-resize",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_encrypted_method_info_convert_IN_ARG_target_version =
{
  {
    -1,
    (gchar *) "target_version",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_encrypted_method_info_convert_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_encrypted_method_info_convert_IN_ARG_pointers[] =
{
  &_udisks_encrypted_method_info_convert_IN_ARG_target_version.parent_struct,
  &_udisks_encrypted_method_info_convert_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_encrypted_method_info_convert =
{
  {
    -1,
    (gchar *) "Convert",
    (GDBusArgInfo **) &_udisks_encrypted_method_info_convert_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-convert",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_encrypted_method_info_header_backup_IN_ARG_backup_file =
{
  {
    -1,
    (gchar *) "backup_file",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_encrypted_method_info_header_backup_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_encrypted_method_info_header_backup_IN_ARG_pointers[] =
{
  &_udisks_encrypted_method_info_header_backup_IN_ARG_backup_file.parent_struct,
  &_udisks_encrypted_method_info_header_backup_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_encrypted_method_info_header_backup =
{
  {
    -1,
    (gchar *) "HeaderBackup",
    (GDBusArgInfo **) &_udisks_encrypted_method_info_header_backup_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-header-backup",
  FALSE
};

static const GDBusMethodInfo * const _udisks_encrypted_method_info_pointers[] =
{
  &_udisks_encrypted_method_info_unlock.parent_struct,
  &_udisks_encrypted_method_info_lock.parent_struct,
  &_udisks_encrypted_method_info_change_passphrase.parent_struct,
  &_udisks_encrypted_method_info_resize.parent_struct,
  &_udisks_encrypted_method_info_convert.parent_struct,
  &_udisks_encrypted_method_info_header_backup.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_encrypted_property_info_child_configuration =
{
  {
    -1,
    (gchar *) "ChildConfiguration",
    (gchar *) "a(sa{sv})",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "child-configuration",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_encrypted_property_info_hint_encryption_type =
{
  {
    -1,
    (gchar *) "HintEncryptionType",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "hint-encryption-type",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_encrypted_property_info_metadata_size =
{
  {
    -1,
    (gchar *) "MetadataSize",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "metadata-size",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_encrypted_property_info_cleartext_device =
{
  {
    -1,
    (gchar *) "CleartextDevice",
    (gchar *) "o",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "cleartext-device",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_encrypted_property_info_pointers[] =
{
  &_udisks_encrypted_property_info_child_configuration.parent_struct,
  &_udisks_encrypted_property_info_hint_encryption_type.parent_struct,
  &_udisks_encrypted_property_info_metadata_size.parent_struct,
  &_udisks_encrypted_property_info_cleartext_device.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_encrypted_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Encrypted",
    (GDBusMethodInfo **) &_udisks_encrypted_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_encrypted_property_info_pointers,
    NULL
  },
  "encrypted",
};


/**
 * udisks_encrypted_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Encrypted.top_of_page">org.freedesktop.UDisks2.Encrypted</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_encrypted_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_encrypted_interface_info.parent_struct;
}

/**
 * udisks_encrypted_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksEncrypted interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_encrypted_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "child-configuration");
  g_object_class_override_property (klass, property_id_begin++, "hint-encryption-type");
  g_object_class_override_property (klass, property_id_begin++, "metadata-size");
  g_object_class_override_property (klass, property_id_begin++, "cleartext-device");
  return property_id_begin - 1;
}


inline static void
udisks_encrypted_method_marshal_unlock (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_encrypted_method_marshal_lock (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_encrypted_method_marshal_change_passphrase (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_encrypted_method_marshal_resize (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT64_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_encrypted_method_marshal_convert (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_encrypted_method_marshal_header_backup (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksEncrypted:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Encrypted.top_of_page">org.freedesktop.UDisks2.Encrypted</link>.
 */

/**
 * UDisksEncryptedIface:
 * @parent_iface: The parent interface.
 * @handle_change_passphrase: Handler for the #UDisksEncrypted::handle-change-passphrase signal.
 * @handle_lock: Handler for the #UDisksEncrypted::handle-lock signal.
 * @handle_unlock: Handler for the #UDisksEncrypted::handle-unlock signal.
 * @get_child_configuration: Getter for the #UDisksEncrypted:child-configuration property.
 * @get_cleartext_device: Getter for the #UDisksEncrypted:cleartext-device property.
 * @get_hint_encryption_type: Getter for the #UDisksEncrypted:hint-encryption-type property.
 * @get_metadata_size: Getter for the #UDisksEncrypted:metadata-size property.
 * @handle_resize: Handler for the #UDisksEncrypted::handle-resize signal.
 * @handle_convert: Handler for the #UDisksEncrypted::handle-convert signal.
 * @handle_header_backup: Handler for the #UDisksEncrypted::handle-header-backup signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Encrypted.top_of_page">org.freedesktop.UDisks2.Encrypted</link>.
 */

typedef UDisksEncryptedIface UDisksEncryptedInterface;
G_DEFINE_INTERFACE (UDisksEncrypted, udisks_encrypted, G_TYPE_OBJECT)

static void
udisks_encrypted_default_init (UDisksEncryptedIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksEncrypted::handle-unlock:
   * @object: A #UDisksEncrypted.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_passphrase: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Unlock">Unlock()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_encrypted_complete_unlock() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-unlock",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksEncryptedIface, handle_unlock),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_encrypted_method_marshal_unlock,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksEncrypted::handle-lock:
   * @object: A #UDisksEncrypted.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Lock">Lock()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_encrypted_complete_lock() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-lock",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksEncryptedIface, handle_lock),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_encrypted_method_marshal_lock,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksEncrypted::handle-change-passphrase:
   * @object: A #UDisksEncrypted.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_passphrase: Argument passed by remote caller.
   * @arg_new_passphrase: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.ChangePassphrase">ChangePassphrase()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_encrypted_complete_change_passphrase() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-change-passphrase",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksEncryptedIface, handle_change_passphrase),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_encrypted_method_marshal_change_passphrase,
    G_TYPE_BOOLEAN,
    4,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksEncrypted::handle-resize:
   * @object: A #UDisksEncrypted.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_size: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Resize">Resize()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_encrypted_complete_resize() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.8.0
   */
  g_signal_new ("handle-resize",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksEncryptedIface, handle_resize),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_encrypted_method_marshal_resize,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT64, G_TYPE_VARIANT);

  /**
   * UDisksEncrypted::handle-convert:
   * @object: A #UDisksEncrypted.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_target_version: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Convert">Convert()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_encrypted_complete_convert() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.11.0
   */
  g_signal_new ("handle-convert",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksEncryptedIface, handle_convert),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_encrypted_method_marshal_convert,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksEncrypted::handle-header-backup:
   * @object: A #UDisksEncrypted.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_backup_file: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.HeaderBackup">HeaderBackup()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_encrypted_complete_header_backup() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.11.0
   */
  g_signal_new ("handle-header-backup",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksEncryptedIface, handle_header_backup),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_encrypted_method_marshal_header_backup,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksEncrypted:child-configuration:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.ChildConfiguration">"ChildConfiguration"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_variant ("child-configuration", "ChildConfiguration", "ChildConfiguration", G_VARIANT_TYPE ("a(sa{sv})"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksEncrypted:hint-encryption-type:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.HintEncryptionType">"HintEncryptionType"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("hint-encryption-type", "HintEncryptionType", "HintEncryptionType", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksEncrypted:metadata-size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.MetadataSize">"MetadataSize"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("metadata-size", "MetadataSize", "MetadataSize", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksEncrypted:cleartext-device:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.CleartextDevice">"CleartextDevice"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("cleartext-device", "CleartextDevice", "CleartextDevice", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_encrypted_get_child_configuration: (skip)
 * @object: A #UDisksEncrypted.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.ChildConfiguration">"ChildConfiguration"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_encrypted_dup_child_configuration() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
GVariant *
udisks_encrypted_get_child_configuration (UDisksEncrypted *object)
{
  g_return_val_if_fail (UDISKS_IS_ENCRYPTED (object), NULL);

  return UDISKS_ENCRYPTED_GET_IFACE (object)->get_child_configuration (object);
}

/**
 * udisks_encrypted_dup_child_configuration: (skip)
 * @object: A #UDisksEncrypted.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.ChildConfiguration">"ChildConfiguration"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_variant_unref().
 */
GVariant *
udisks_encrypted_dup_child_configuration (UDisksEncrypted *object)
{
  GVariant *value;
  g_object_get (G_OBJECT (object), "child-configuration", &value, NULL);
  return value;
}

/**
 * udisks_encrypted_set_child_configuration: (skip)
 * @object: A #UDisksEncrypted.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.ChildConfiguration">"ChildConfiguration"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_encrypted_set_child_configuration (UDisksEncrypted *object, GVariant *value)
{
  g_object_set (G_OBJECT (object), "child-configuration", value, NULL);
}

/**
 * udisks_encrypted_get_hint_encryption_type: (skip)
 * @object: A #UDisksEncrypted.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.HintEncryptionType">"HintEncryptionType"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_encrypted_dup_hint_encryption_type() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_encrypted_get_hint_encryption_type (UDisksEncrypted *object)
{
  g_return_val_if_fail (UDISKS_IS_ENCRYPTED (object), NULL);

  return UDISKS_ENCRYPTED_GET_IFACE (object)->get_hint_encryption_type (object);
}

/**
 * udisks_encrypted_dup_hint_encryption_type: (skip)
 * @object: A #UDisksEncrypted.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.HintEncryptionType">"HintEncryptionType"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_encrypted_dup_hint_encryption_type (UDisksEncrypted *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "hint-encryption-type", &value, NULL);
  return value;
}

/**
 * udisks_encrypted_set_hint_encryption_type: (skip)
 * @object: A #UDisksEncrypted.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.HintEncryptionType">"HintEncryptionType"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_encrypted_set_hint_encryption_type (UDisksEncrypted *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "hint-encryption-type", value, NULL);
}

/**
 * udisks_encrypted_get_metadata_size: (skip)
 * @object: A #UDisksEncrypted.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.MetadataSize">"MetadataSize"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_encrypted_get_metadata_size (UDisksEncrypted *object)
{
  g_return_val_if_fail (UDISKS_IS_ENCRYPTED (object), 0);

  return UDISKS_ENCRYPTED_GET_IFACE (object)->get_metadata_size (object);
}

/**
 * udisks_encrypted_set_metadata_size: (skip)
 * @object: A #UDisksEncrypted.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.MetadataSize">"MetadataSize"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_encrypted_set_metadata_size (UDisksEncrypted *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "metadata-size", value, NULL);
}

/**
 * udisks_encrypted_get_cleartext_device: (skip)
 * @object: A #UDisksEncrypted.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.CleartextDevice">"CleartextDevice"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_encrypted_dup_cleartext_device() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_encrypted_get_cleartext_device (UDisksEncrypted *object)
{
  g_return_val_if_fail (UDISKS_IS_ENCRYPTED (object), NULL);

  return UDISKS_ENCRYPTED_GET_IFACE (object)->get_cleartext_device (object);
}

/**
 * udisks_encrypted_dup_cleartext_device: (skip)
 * @object: A #UDisksEncrypted.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.CleartextDevice">"CleartextDevice"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_encrypted_dup_cleartext_device (UDisksEncrypted *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "cleartext-device", &value, NULL);
  return value;
}

/**
 * udisks_encrypted_set_cleartext_device: (skip)
 * @object: A #UDisksEncrypted.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Encrypted.CleartextDevice">"CleartextDevice"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_encrypted_set_cleartext_device (UDisksEncrypted *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "cleartext-device", value, NULL);
}

/**
 * udisks_encrypted_call_unlock:
 * @proxy: A #UDisksEncryptedProxy.
 * @arg_passphrase: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Unlock">Unlock()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_encrypted_call_unlock_finish() to get the result of the operation.
 *
 * See udisks_encrypted_call_unlock_sync() for the synchronous, blocking version of this method.
 */
void
udisks_encrypted_call_unlock (
    UDisksEncrypted *proxy,
    const gchar *arg_passphrase,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Unlock",
    g_variant_new ("(s@a{sv})",
                   arg_passphrase,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_encrypted_call_unlock_finish:
 * @proxy: A #UDisksEncryptedProxy.
 * @out_cleartext_device: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_encrypted_call_unlock().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_encrypted_call_unlock().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_encrypted_call_unlock_finish (
    UDisksEncrypted *proxy,
    gchar ** out_cleartext_device,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_cleartext_device);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_encrypted_call_unlock_sync:
 * @proxy: A #UDisksEncryptedProxy.
 * @arg_passphrase: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_cleartext_device: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Unlock">Unlock()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_encrypted_call_unlock() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_encrypted_call_unlock_sync (
    UDisksEncrypted *proxy,
    const gchar *arg_passphrase,
    GVariant *arg_options,
    gchar ** out_cleartext_device,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Unlock",
    g_variant_new ("(s@a{sv})",
                   arg_passphrase,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_cleartext_device);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_encrypted_call_lock:
 * @proxy: A #UDisksEncryptedProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Lock">Lock()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_encrypted_call_lock_finish() to get the result of the operation.
 *
 * See udisks_encrypted_call_lock_sync() for the synchronous, blocking version of this method.
 */
void
udisks_encrypted_call_lock (
    UDisksEncrypted *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Lock",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_encrypted_call_lock_finish:
 * @proxy: A #UDisksEncryptedProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_encrypted_call_lock().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_encrypted_call_lock().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_encrypted_call_lock_finish (
    UDisksEncrypted *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_encrypted_call_lock_sync:
 * @proxy: A #UDisksEncryptedProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Lock">Lock()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_encrypted_call_lock() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_encrypted_call_lock_sync (
    UDisksEncrypted *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Lock",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_encrypted_call_change_passphrase:
 * @proxy: A #UDisksEncryptedProxy.
 * @arg_passphrase: Argument to pass with the method invocation.
 * @arg_new_passphrase: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.ChangePassphrase">ChangePassphrase()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_encrypted_call_change_passphrase_finish() to get the result of the operation.
 *
 * See udisks_encrypted_call_change_passphrase_sync() for the synchronous, blocking version of this method.
 */
void
udisks_encrypted_call_change_passphrase (
    UDisksEncrypted *proxy,
    const gchar *arg_passphrase,
    const gchar *arg_new_passphrase,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "ChangePassphrase",
    g_variant_new ("(ss@a{sv})",
                   arg_passphrase,
                   arg_new_passphrase,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_encrypted_call_change_passphrase_finish:
 * @proxy: A #UDisksEncryptedProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_encrypted_call_change_passphrase().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_encrypted_call_change_passphrase().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_encrypted_call_change_passphrase_finish (
    UDisksEncrypted *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_encrypted_call_change_passphrase_sync:
 * @proxy: A #UDisksEncryptedProxy.
 * @arg_passphrase: Argument to pass with the method invocation.
 * @arg_new_passphrase: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.ChangePassphrase">ChangePassphrase()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_encrypted_call_change_passphrase() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_encrypted_call_change_passphrase_sync (
    UDisksEncrypted *proxy,
    const gchar *arg_passphrase,
    const gchar *arg_new_passphrase,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "ChangePassphrase",
    g_variant_new ("(ss@a{sv})",
                   arg_passphrase,
                   arg_new_passphrase,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_encrypted_call_resize:
 * @proxy: A #UDisksEncryptedProxy.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Resize">Resize()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_encrypted_call_resize_finish() to get the result of the operation.
 *
 * See udisks_encrypted_call_resize_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.8.0
 */
void
udisks_encrypted_call_resize (
    UDisksEncrypted *proxy,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Resize",
    g_variant_new ("(t@a{sv})",
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_encrypted_call_resize_finish:
 * @proxy: A #UDisksEncryptedProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_encrypted_call_resize().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_encrypted_call_resize().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.8.0
 */
gboolean
udisks_encrypted_call_resize_finish (
    UDisksEncrypted *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_encrypted_call_resize_sync:
 * @proxy: A #UDisksEncryptedProxy.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Resize">Resize()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_encrypted_call_resize() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.8.0
 */
gboolean
udisks_encrypted_call_resize_sync (
    UDisksEncrypted *proxy,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Resize",
    g_variant_new ("(t@a{sv})",
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_encrypted_call_convert:
 * @proxy: A #UDisksEncryptedProxy.
 * @arg_target_version: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Convert">Convert()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_encrypted_call_convert_finish() to get the result of the operation.
 *
 * See udisks_encrypted_call_convert_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.11.0
 */
void
udisks_encrypted_call_convert (
    UDisksEncrypted *proxy,
    const gchar *arg_target_version,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Convert",
    g_variant_new ("(s@a{sv})",
                   arg_target_version,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_encrypted_call_convert_finish:
 * @proxy: A #UDisksEncryptedProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_encrypted_call_convert().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_encrypted_call_convert().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11.0
 */
gboolean
udisks_encrypted_call_convert_finish (
    UDisksEncrypted *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_encrypted_call_convert_sync:
 * @proxy: A #UDisksEncryptedProxy.
 * @arg_target_version: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Convert">Convert()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_encrypted_call_convert() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11.0
 */
gboolean
udisks_encrypted_call_convert_sync (
    UDisksEncrypted *proxy,
    const gchar *arg_target_version,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Convert",
    g_variant_new ("(s@a{sv})",
                   arg_target_version,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_encrypted_call_header_backup:
 * @proxy: A #UDisksEncryptedProxy.
 * @arg_backup_file: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.HeaderBackup">HeaderBackup()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_encrypted_call_header_backup_finish() to get the result of the operation.
 *
 * See udisks_encrypted_call_header_backup_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.11.0
 */
void
udisks_encrypted_call_header_backup (
    UDisksEncrypted *proxy,
    const gchar *arg_backup_file,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "HeaderBackup",
    g_variant_new ("(s@a{sv})",
                   arg_backup_file,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_encrypted_call_header_backup_finish:
 * @proxy: A #UDisksEncryptedProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_encrypted_call_header_backup().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_encrypted_call_header_backup().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11.0
 */
gboolean
udisks_encrypted_call_header_backup_finish (
    UDisksEncrypted *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_encrypted_call_header_backup_sync:
 * @proxy: A #UDisksEncryptedProxy.
 * @arg_backup_file: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.HeaderBackup">HeaderBackup()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_encrypted_call_header_backup() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11.0
 */
gboolean
udisks_encrypted_call_header_backup_sync (
    UDisksEncrypted *proxy,
    const gchar *arg_backup_file,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "HeaderBackup",
    g_variant_new ("(s@a{sv})",
                   arg_backup_file,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_encrypted_complete_unlock:
 * @object: A #UDisksEncrypted.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @cleartext_device: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Unlock">Unlock()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_encrypted_complete_unlock (
    UDisksEncrypted *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *cleartext_device)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   cleartext_device));
}

/**
 * udisks_encrypted_complete_lock:
 * @object: A #UDisksEncrypted.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Lock">Lock()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_encrypted_complete_lock (
    UDisksEncrypted *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_encrypted_complete_change_passphrase:
 * @object: A #UDisksEncrypted.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.ChangePassphrase">ChangePassphrase()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_encrypted_complete_change_passphrase (
    UDisksEncrypted *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_encrypted_complete_resize:
 * @object: A #UDisksEncrypted.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Resize">Resize()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.8.0
 */
void
udisks_encrypted_complete_resize (
    UDisksEncrypted *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_encrypted_complete_convert:
 * @object: A #UDisksEncrypted.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.Convert">Convert()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.11.0
 */
void
udisks_encrypted_complete_convert (
    UDisksEncrypted *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_encrypted_complete_header_backup:
 * @object: A #UDisksEncrypted.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Encrypted.HeaderBackup">HeaderBackup()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.11.0
 */
void
udisks_encrypted_complete_header_backup (
    UDisksEncrypted *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksEncryptedProxy:
 *
 * The #UDisksEncryptedProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksEncryptedProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksEncryptedProxy.
 */

struct _UDisksEncryptedProxyPrivate
{
  GData *qdata;
};

static void udisks_encrypted_proxy_iface_init (UDisksEncryptedIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksEncryptedProxy, udisks_encrypted_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksEncryptedProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_ENCRYPTED, udisks_encrypted_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksEncryptedProxy, udisks_encrypted_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_ENCRYPTED, udisks_encrypted_proxy_iface_init))

#endif
static void
udisks_encrypted_proxy_finalize (GObject *object)
{
  UDisksEncryptedProxy *proxy = UDISKS_ENCRYPTED_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_encrypted_proxy_parent_class)->finalize (object);
}

static void
udisks_encrypted_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_encrypted_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_encrypted_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.Encrypted: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_encrypted_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_encrypted_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.Encrypted", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_encrypted_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_encrypted_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_encrypted_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_ENCRYPTED);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_ENCRYPTED);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_encrypted_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksEncryptedProxy *proxy = UDISKS_ENCRYPTED_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_encrypted_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_encrypted_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static GVariant *
udisks_encrypted_proxy_get_child_configuration (UDisksEncrypted *object)
{
  UDisksEncryptedProxy *proxy = UDISKS_ENCRYPTED_PROXY (object);
  GVariant *variant;
  GVariant *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ChildConfiguration");
  value = variant;
  if (variant != NULL)
    g_variant_unref (variant);
  return value;
}

static const gchar *
udisks_encrypted_proxy_get_hint_encryption_type (UDisksEncrypted *object)
{
  UDisksEncryptedProxy *proxy = UDISKS_ENCRYPTED_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "HintEncryptionType");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_encrypted_proxy_get_metadata_size (UDisksEncrypted *object)
{
  UDisksEncryptedProxy *proxy = UDISKS_ENCRYPTED_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "MetadataSize");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_encrypted_proxy_get_cleartext_device (UDisksEncrypted *object)
{
  UDisksEncryptedProxy *proxy = UDISKS_ENCRYPTED_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "CleartextDevice");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_encrypted_proxy_init (UDisksEncryptedProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_encrypted_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_ENCRYPTED_PROXY, UDisksEncryptedProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_encrypted_interface_info ());
}

static void
udisks_encrypted_proxy_class_init (UDisksEncryptedProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_encrypted_proxy_finalize;
  gobject_class->get_property = udisks_encrypted_proxy_get_property;
  gobject_class->set_property = udisks_encrypted_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_encrypted_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_encrypted_proxy_g_properties_changed;

  udisks_encrypted_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksEncryptedProxyPrivate));
#endif
}

static void
udisks_encrypted_proxy_iface_init (UDisksEncryptedIface *iface)
{
  iface->get_child_configuration = udisks_encrypted_proxy_get_child_configuration;
  iface->get_hint_encryption_type = udisks_encrypted_proxy_get_hint_encryption_type;
  iface->get_metadata_size = udisks_encrypted_proxy_get_metadata_size;
  iface->get_cleartext_device = udisks_encrypted_proxy_get_cleartext_device;
}

/**
 * udisks_encrypted_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Encrypted.top_of_page">org.freedesktop.UDisks2.Encrypted</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_encrypted_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_encrypted_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_encrypted_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_ENCRYPTED_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Encrypted", NULL);
}

/**
 * udisks_encrypted_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_encrypted_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_encrypted_proxy_new().
 *
 * Returns: (transfer full) (type UDisksEncryptedProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksEncrypted *
udisks_encrypted_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_ENCRYPTED (ret);
  else
    return NULL;
}

/**
 * udisks_encrypted_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Encrypted.top_of_page">org.freedesktop.UDisks2.Encrypted</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_encrypted_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksEncryptedProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksEncrypted *
udisks_encrypted_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_ENCRYPTED_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Encrypted", NULL);
  if (ret != NULL)
    return UDISKS_ENCRYPTED (ret);
  else
    return NULL;
}


/**
 * udisks_encrypted_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_encrypted_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_encrypted_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_encrypted_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_encrypted_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_ENCRYPTED_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Encrypted", NULL);
}

/**
 * udisks_encrypted_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_encrypted_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_encrypted_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksEncryptedProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksEncrypted *
udisks_encrypted_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_ENCRYPTED (ret);
  else
    return NULL;
}

/**
 * udisks_encrypted_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_encrypted_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_encrypted_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksEncryptedProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksEncrypted *
udisks_encrypted_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_ENCRYPTED_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Encrypted", NULL);
  if (ret != NULL)
    return UDISKS_ENCRYPTED (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksEncryptedSkeleton:
 *
 * The #UDisksEncryptedSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksEncryptedSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksEncryptedSkeleton.
 */

struct _UDisksEncryptedSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_encrypted_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_ENCRYPTED);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_ENCRYPTED);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_encrypted_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_encrypted_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_encrypted_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_encrypted_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_encrypted_skeleton_vtable =
{
  _udisks_encrypted_skeleton_handle_method_call,
  _udisks_encrypted_skeleton_handle_get_property,
  _udisks_encrypted_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_encrypted_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_encrypted_interface_info ();
}

static GDBusInterfaceVTable *
udisks_encrypted_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_encrypted_skeleton_vtable;
}

static GVariant *
udisks_encrypted_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_encrypted_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_encrypted_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_encrypted_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_encrypted_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Encrypted", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_encrypted_emit_changed (gpointer user_data);

static void
udisks_encrypted_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_encrypted_emit_changed (skeleton);
}

static void udisks_encrypted_skeleton_iface_init (UDisksEncryptedIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksEncryptedSkeleton, udisks_encrypted_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksEncryptedSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_ENCRYPTED, udisks_encrypted_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksEncryptedSkeleton, udisks_encrypted_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_ENCRYPTED, udisks_encrypted_skeleton_iface_init))

#endif
static void
udisks_encrypted_skeleton_finalize (GObject *object)
{
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (object);
  guint n;
  for (n = 0; n < 4; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_encrypted_skeleton_parent_class)->finalize (object);
}

static void
udisks_encrypted_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_encrypted_emit_changed (gpointer user_data)
{
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.Encrypted",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_encrypted_schedule_emit_changed (UDisksEncryptedSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_encrypted_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_encrypted_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_encrypted_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_encrypted_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_encrypted_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_encrypted_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_encrypted_skeleton_init (UDisksEncryptedSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_encrypted_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_ENCRYPTED_SKELETON, UDisksEncryptedSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 4);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_VARIANT);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_STRING);
}

static GVariant *
udisks_encrypted_skeleton_get_child_configuration (UDisksEncrypted *object)
{
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (object);
  GVariant *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_variant (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_encrypted_skeleton_get_hint_encryption_type (UDisksEncrypted *object)
{
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_encrypted_skeleton_get_metadata_size (UDisksEncrypted *object)
{
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_encrypted_skeleton_get_cleartext_device (UDisksEncrypted *object)
{
  UDisksEncryptedSkeleton *skeleton = UDISKS_ENCRYPTED_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_encrypted_skeleton_class_init (UDisksEncryptedSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_encrypted_skeleton_finalize;
  gobject_class->get_property = udisks_encrypted_skeleton_get_property;
  gobject_class->set_property = udisks_encrypted_skeleton_set_property;
  gobject_class->notify       = udisks_encrypted_skeleton_notify;


  udisks_encrypted_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_encrypted_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_encrypted_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_encrypted_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_encrypted_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksEncryptedSkeletonPrivate));
#endif
}

static void
udisks_encrypted_skeleton_iface_init (UDisksEncryptedIface *iface)
{
  iface->get_child_configuration = udisks_encrypted_skeleton_get_child_configuration;
  iface->get_hint_encryption_type = udisks_encrypted_skeleton_get_hint_encryption_type;
  iface->get_metadata_size = udisks_encrypted_skeleton_get_metadata_size;
  iface->get_cleartext_device = udisks_encrypted_skeleton_get_cleartext_device;
}

/**
 * udisks_encrypted_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Encrypted.top_of_page">org.freedesktop.UDisks2.Encrypted</link>.
 *
 * Returns: (transfer full) (type UDisksEncryptedSkeleton): The skeleton object.
 */
UDisksEncrypted *
udisks_encrypted_skeleton_new (void)
{
  return UDISKS_ENCRYPTED (g_object_new (UDISKS_TYPE_ENCRYPTED_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Loop
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksLoop
 * @title: UDisksLoop
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Loop D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Loop.top_of_page">org.freedesktop.UDisks2.Loop</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Loop ---- */

static const _ExtendedGDBusArgInfo _udisks_loop_method_info_delete_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_loop_method_info_delete_IN_ARG_pointers[] =
{
  &_udisks_loop_method_info_delete_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_loop_method_info_delete =
{
  {
    -1,
    (gchar *) "Delete",
    (GDBusArgInfo **) &_udisks_loop_method_info_delete_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-delete",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_loop_method_info_set_autoclear_IN_ARG_value =
{
  {
    -1,
    (gchar *) "value",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_loop_method_info_set_autoclear_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_loop_method_info_set_autoclear_IN_ARG_pointers[] =
{
  &_udisks_loop_method_info_set_autoclear_IN_ARG_value.parent_struct,
  &_udisks_loop_method_info_set_autoclear_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_loop_method_info_set_autoclear =
{
  {
    -1,
    (gchar *) "SetAutoclear",
    (GDBusArgInfo **) &_udisks_loop_method_info_set_autoclear_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-autoclear",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_loop_method_info_set_capacity_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_loop_method_info_set_capacity_IN_ARG_pointers[] =
{
  &_udisks_loop_method_info_set_capacity_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_loop_method_info_set_capacity =
{
  {
    -1,
    (gchar *) "SetCapacity",
    (GDBusArgInfo **) &_udisks_loop_method_info_set_capacity_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-capacity",
  FALSE
};

static const GDBusMethodInfo * const _udisks_loop_method_info_pointers[] =
{
  &_udisks_loop_method_info_delete.parent_struct,
  &_udisks_loop_method_info_set_autoclear.parent_struct,
  &_udisks_loop_method_info_set_capacity.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_loop_property_info_backing_file =
{
  {
    -1,
    (gchar *) "BackingFile",
    (gchar *) "ay",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "backing-file",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_loop_property_info_autoclear =
{
  {
    -1,
    (gchar *) "Autoclear",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "autoclear",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_loop_property_info_setup_by_uid =
{
  {
    -1,
    (gchar *) "SetupByUID",
    (gchar *) "u",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "setup-by-uid",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_loop_property_info_pointers[] =
{
  &_udisks_loop_property_info_backing_file.parent_struct,
  &_udisks_loop_property_info_autoclear.parent_struct,
  &_udisks_loop_property_info_setup_by_uid.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_loop_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Loop",
    (GDBusMethodInfo **) &_udisks_loop_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_loop_property_info_pointers,
    NULL
  },
  "loop",
};


/**
 * udisks_loop_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Loop.top_of_page">org.freedesktop.UDisks2.Loop</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_loop_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_loop_interface_info.parent_struct;
}

/**
 * udisks_loop_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksLoop interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_loop_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "backing-file");
  g_object_class_override_property (klass, property_id_begin++, "autoclear");
  g_object_class_override_property (klass, property_id_begin++, "setup-by-uid");
  return property_id_begin - 1;
}


inline static void
udisks_loop_method_marshal_delete (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_loop_method_marshal_set_autoclear (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOOLEAN_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_loop_method_marshal_set_capacity (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksLoop:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Loop.top_of_page">org.freedesktop.UDisks2.Loop</link>.
 */

/**
 * UDisksLoopIface:
 * @parent_iface: The parent interface.
 * @handle_delete: Handler for the #UDisksLoop::handle-delete signal.
 * @handle_set_autoclear: Handler for the #UDisksLoop::handle-set-autoclear signal.
 * @get_autoclear: Getter for the #UDisksLoop:autoclear property.
 * @get_backing_file: Getter for the #UDisksLoop:backing-file property.
 * @get_setup_by_uid: Getter for the #UDisksLoop:setup-by-uid property.
 * @handle_set_capacity: Handler for the #UDisksLoop::handle-set-capacity signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Loop.top_of_page">org.freedesktop.UDisks2.Loop</link>.
 */

typedef UDisksLoopIface UDisksLoopInterface;
G_DEFINE_INTERFACE (UDisksLoop, udisks_loop, G_TYPE_OBJECT)

static void
udisks_loop_default_init (UDisksLoopIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksLoop::handle-delete:
   * @object: A #UDisksLoop.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Loop.Delete">Delete()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_loop_complete_delete() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-delete",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksLoopIface, handle_delete),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_loop_method_marshal_delete,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksLoop::handle-set-autoclear:
   * @object: A #UDisksLoop.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_value: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Loop.SetAutoclear">SetAutoclear()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_loop_complete_set_autoclear() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-set-autoclear",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksLoopIface, handle_set_autoclear),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_loop_method_marshal_set_autoclear,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_BOOLEAN, G_TYPE_VARIANT);

  /**
   * UDisksLoop::handle-set-capacity:
   * @object: A #UDisksLoop.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Loop.SetCapacity">SetCapacity()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_loop_complete_set_capacity() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.11.0
   */
  g_signal_new ("handle-set-capacity",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksLoopIface, handle_set_capacity),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_loop_method_marshal_set_capacity,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksLoop:backing-file:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Loop.BackingFile">"BackingFile"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("backing-file", "BackingFile", "BackingFile", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLoop:autoclear:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Loop.Autoclear">"Autoclear"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("autoclear", "Autoclear", "Autoclear", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLoop:setup-by-uid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Loop.SetupByUID">"SetupByUID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint ("setup-by-uid", "SetupByUID", "SetupByUID", 0, G_MAXUINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_loop_get_backing_file: (skip)
 * @object: A #UDisksLoop.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Loop.BackingFile">"BackingFile"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_loop_dup_backing_file() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_loop_get_backing_file (UDisksLoop *object)
{
  g_return_val_if_fail (UDISKS_IS_LOOP (object), NULL);

  return UDISKS_LOOP_GET_IFACE (object)->get_backing_file (object);
}

/**
 * udisks_loop_dup_backing_file: (skip)
 * @object: A #UDisksLoop.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Loop.BackingFile">"BackingFile"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_loop_dup_backing_file (UDisksLoop *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "backing-file", &value, NULL);
  return value;
}

/**
 * udisks_loop_set_backing_file: (skip)
 * @object: A #UDisksLoop.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Loop.BackingFile">"BackingFile"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_loop_set_backing_file (UDisksLoop *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "backing-file", value, NULL);
}

/**
 * udisks_loop_get_autoclear: (skip)
 * @object: A #UDisksLoop.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Loop.Autoclear">"Autoclear"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_loop_get_autoclear (UDisksLoop *object)
{
  g_return_val_if_fail (UDISKS_IS_LOOP (object), FALSE);

  return UDISKS_LOOP_GET_IFACE (object)->get_autoclear (object);
}

/**
 * udisks_loop_set_autoclear: (skip)
 * @object: A #UDisksLoop.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Loop.Autoclear">"Autoclear"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_loop_set_autoclear (UDisksLoop *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "autoclear", value, NULL);
}

/**
 * udisks_loop_get_setup_by_uid: (skip)
 * @object: A #UDisksLoop.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Loop.SetupByUID">"SetupByUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint 
udisks_loop_get_setup_by_uid (UDisksLoop *object)
{
  g_return_val_if_fail (UDISKS_IS_LOOP (object), 0);

  return UDISKS_LOOP_GET_IFACE (object)->get_setup_by_uid (object);
}

/**
 * udisks_loop_set_setup_by_uid: (skip)
 * @object: A #UDisksLoop.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Loop.SetupByUID">"SetupByUID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_loop_set_setup_by_uid (UDisksLoop *object, guint value)
{
  g_object_set (G_OBJECT (object), "setup-by-uid", value, NULL);
}

/**
 * udisks_loop_call_delete:
 * @proxy: A #UDisksLoopProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Loop.Delete">Delete()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_loop_call_delete_finish() to get the result of the operation.
 *
 * See udisks_loop_call_delete_sync() for the synchronous, blocking version of this method.
 */
void
udisks_loop_call_delete (
    UDisksLoop *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Delete",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_loop_call_delete_finish:
 * @proxy: A #UDisksLoopProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_loop_call_delete().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_loop_call_delete().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_loop_call_delete_finish (
    UDisksLoop *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_loop_call_delete_sync:
 * @proxy: A #UDisksLoopProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Loop.Delete">Delete()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_loop_call_delete() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_loop_call_delete_sync (
    UDisksLoop *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Delete",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_loop_call_set_autoclear:
 * @proxy: A #UDisksLoopProxy.
 * @arg_value: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Loop.SetAutoclear">SetAutoclear()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_loop_call_set_autoclear_finish() to get the result of the operation.
 *
 * See udisks_loop_call_set_autoclear_sync() for the synchronous, blocking version of this method.
 */
void
udisks_loop_call_set_autoclear (
    UDisksLoop *proxy,
    gboolean arg_value,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetAutoclear",
    g_variant_new ("(b@a{sv})",
                   arg_value,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_loop_call_set_autoclear_finish:
 * @proxy: A #UDisksLoopProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_loop_call_set_autoclear().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_loop_call_set_autoclear().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_loop_call_set_autoclear_finish (
    UDisksLoop *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_loop_call_set_autoclear_sync:
 * @proxy: A #UDisksLoopProxy.
 * @arg_value: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Loop.SetAutoclear">SetAutoclear()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_loop_call_set_autoclear() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_loop_call_set_autoclear_sync (
    UDisksLoop *proxy,
    gboolean arg_value,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetAutoclear",
    g_variant_new ("(b@a{sv})",
                   arg_value,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_loop_call_set_capacity:
 * @proxy: A #UDisksLoopProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Loop.SetCapacity">SetCapacity()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_loop_call_set_capacity_finish() to get the result of the operation.
 *
 * See udisks_loop_call_set_capacity_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.11.0
 */
void
udisks_loop_call_set_capacity (
    UDisksLoop *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetCapacity",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_loop_call_set_capacity_finish:
 * @proxy: A #UDisksLoopProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_loop_call_set_capacity().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_loop_call_set_capacity().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11.0
 */
gboolean
udisks_loop_call_set_capacity_finish (
    UDisksLoop *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_loop_call_set_capacity_sync:
 * @proxy: A #UDisksLoopProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Loop.SetCapacity">SetCapacity()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_loop_call_set_capacity() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11.0
 */
gboolean
udisks_loop_call_set_capacity_sync (
    UDisksLoop *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetCapacity",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_loop_complete_delete:
 * @object: A #UDisksLoop.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Loop.Delete">Delete()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_loop_complete_delete (
    UDisksLoop *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_loop_complete_set_autoclear:
 * @object: A #UDisksLoop.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Loop.SetAutoclear">SetAutoclear()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_loop_complete_set_autoclear (
    UDisksLoop *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_loop_complete_set_capacity:
 * @object: A #UDisksLoop.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Loop.SetCapacity">SetCapacity()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.11.0
 */
void
udisks_loop_complete_set_capacity (
    UDisksLoop *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksLoopProxy:
 *
 * The #UDisksLoopProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksLoopProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksLoopProxy.
 */

struct _UDisksLoopProxyPrivate
{
  GData *qdata;
};

static void udisks_loop_proxy_iface_init (UDisksLoopIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksLoopProxy, udisks_loop_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksLoopProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_LOOP, udisks_loop_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksLoopProxy, udisks_loop_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_LOOP, udisks_loop_proxy_iface_init))

#endif
static void
udisks_loop_proxy_finalize (GObject *object)
{
  UDisksLoopProxy *proxy = UDISKS_LOOP_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_loop_proxy_parent_class)->finalize (object);
}

static void
udisks_loop_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 3);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_loop_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_loop_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.Loop: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_loop_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 3);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_loop_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.Loop", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_loop_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_loop_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_loop_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_LOOP);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_LOOP);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_loop_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksLoopProxy *proxy = UDISKS_LOOP_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_loop_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_loop_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_loop_proxy_get_backing_file (UDisksLoop *object)
{
  UDisksLoopProxy *proxy = UDISKS_LOOP_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "BackingFile");
  if (variant != NULL)
    {
      value = g_variant_get_bytestring (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_loop_proxy_get_autoclear (UDisksLoop *object)
{
  UDisksLoopProxy *proxy = UDISKS_LOOP_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Autoclear");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint 
udisks_loop_proxy_get_setup_by_uid (UDisksLoop *object)
{
  UDisksLoopProxy *proxy = UDISKS_LOOP_PROXY (object);
  GVariant *variant;
  guint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SetupByUID");
  if (variant != NULL)
    {
      value = g_variant_get_uint32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_loop_proxy_init (UDisksLoopProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_loop_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_LOOP_PROXY, UDisksLoopProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_loop_interface_info ());
}

static void
udisks_loop_proxy_class_init (UDisksLoopProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_loop_proxy_finalize;
  gobject_class->get_property = udisks_loop_proxy_get_property;
  gobject_class->set_property = udisks_loop_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_loop_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_loop_proxy_g_properties_changed;

  udisks_loop_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksLoopProxyPrivate));
#endif
}

static void
udisks_loop_proxy_iface_init (UDisksLoopIface *iface)
{
  iface->get_backing_file = udisks_loop_proxy_get_backing_file;
  iface->get_autoclear = udisks_loop_proxy_get_autoclear;
  iface->get_setup_by_uid = udisks_loop_proxy_get_setup_by_uid;
}

/**
 * udisks_loop_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Loop.top_of_page">org.freedesktop.UDisks2.Loop</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_loop_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_loop_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_loop_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_LOOP_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Loop", NULL);
}

/**
 * udisks_loop_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_loop_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_loop_proxy_new().
 *
 * Returns: (transfer full) (type UDisksLoopProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksLoop *
udisks_loop_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_LOOP (ret);
  else
    return NULL;
}

/**
 * udisks_loop_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Loop.top_of_page">org.freedesktop.UDisks2.Loop</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_loop_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksLoopProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksLoop *
udisks_loop_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_LOOP_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Loop", NULL);
  if (ret != NULL)
    return UDISKS_LOOP (ret);
  else
    return NULL;
}


/**
 * udisks_loop_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_loop_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_loop_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_loop_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_loop_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_LOOP_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Loop", NULL);
}

/**
 * udisks_loop_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_loop_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_loop_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksLoopProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksLoop *
udisks_loop_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_LOOP (ret);
  else
    return NULL;
}

/**
 * udisks_loop_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_loop_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_loop_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksLoopProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksLoop *
udisks_loop_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_LOOP_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Loop", NULL);
  if (ret != NULL)
    return UDISKS_LOOP (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksLoopSkeleton:
 *
 * The #UDisksLoopSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksLoopSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksLoopSkeleton.
 */

struct _UDisksLoopSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_loop_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksLoopSkeleton *skeleton = UDISKS_LOOP_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_LOOP);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_LOOP);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_loop_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksLoopSkeleton *skeleton = UDISKS_LOOP_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_loop_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_loop_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksLoopSkeleton *skeleton = UDISKS_LOOP_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_loop_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_loop_skeleton_vtable =
{
  _udisks_loop_skeleton_handle_method_call,
  _udisks_loop_skeleton_handle_get_property,
  _udisks_loop_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_loop_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_loop_interface_info ();
}

static GDBusInterfaceVTable *
udisks_loop_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_loop_skeleton_vtable;
}

static GVariant *
udisks_loop_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksLoopSkeleton *skeleton = UDISKS_LOOP_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_loop_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_loop_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_loop_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_loop_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Loop", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_loop_emit_changed (gpointer user_data);

static void
udisks_loop_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksLoopSkeleton *skeleton = UDISKS_LOOP_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_loop_emit_changed (skeleton);
}

static void udisks_loop_skeleton_iface_init (UDisksLoopIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksLoopSkeleton, udisks_loop_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksLoopSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_LOOP, udisks_loop_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksLoopSkeleton, udisks_loop_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_LOOP, udisks_loop_skeleton_iface_init))

#endif
static void
udisks_loop_skeleton_finalize (GObject *object)
{
  UDisksLoopSkeleton *skeleton = UDISKS_LOOP_SKELETON (object);
  guint n;
  for (n = 0; n < 3; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_loop_skeleton_parent_class)->finalize (object);
}

static void
udisks_loop_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksLoopSkeleton *skeleton = UDISKS_LOOP_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 3);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_loop_emit_changed (gpointer user_data)
{
  UDisksLoopSkeleton *skeleton = UDISKS_LOOP_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.Loop",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_loop_schedule_emit_changed (UDisksLoopSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_loop_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksLoopSkeleton *skeleton = UDISKS_LOOP_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_loop_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_loop_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_loop_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksLoopSkeleton *skeleton = UDISKS_LOOP_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 3);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_loop_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_loop_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_loop_skeleton_init (UDisksLoopSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_loop_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_LOOP_SKELETON, UDisksLoopSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 3);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_UINT);
}

static const gchar *
udisks_loop_skeleton_get_backing_file (UDisksLoop *object)
{
  UDisksLoopSkeleton *skeleton = UDISKS_LOOP_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_loop_skeleton_get_autoclear (UDisksLoop *object)
{
  UDisksLoopSkeleton *skeleton = UDISKS_LOOP_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint 
udisks_loop_skeleton_get_setup_by_uid (UDisksLoop *object)
{
  UDisksLoopSkeleton *skeleton = UDISKS_LOOP_SKELETON (object);
  guint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_loop_skeleton_class_init (UDisksLoopSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_loop_skeleton_finalize;
  gobject_class->get_property = udisks_loop_skeleton_get_property;
  gobject_class->set_property = udisks_loop_skeleton_set_property;
  gobject_class->notify       = udisks_loop_skeleton_notify;


  udisks_loop_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_loop_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_loop_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_loop_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_loop_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksLoopSkeletonPrivate));
#endif
}

static void
udisks_loop_skeleton_iface_init (UDisksLoopIface *iface)
{
  iface->get_backing_file = udisks_loop_skeleton_get_backing_file;
  iface->get_autoclear = udisks_loop_skeleton_get_autoclear;
  iface->get_setup_by_uid = udisks_loop_skeleton_get_setup_by_uid;
}

/**
 * udisks_loop_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Loop.top_of_page">org.freedesktop.UDisks2.Loop</link>.
 *
 * Returns: (transfer full) (type UDisksLoopSkeleton): The skeleton object.
 */
UDisksLoop *
udisks_loop_skeleton_new (void)
{
  return UDISKS_LOOP (g_object_new (UDISKS_TYPE_LOOP_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.MDRaid
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksMDRaid
 * @title: UDisksMDRaid
 * @short_description: Generated C code for the org.freedesktop.UDisks2.MDRaid D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-MDRaid.top_of_page">org.freedesktop.UDisks2.MDRaid</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.MDRaid ---- */

static const _ExtendedGDBusArgInfo _udisks_mdraid_method_info_start_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_mdraid_method_info_start_IN_ARG_pointers[] =
{
  &_udisks_mdraid_method_info_start_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_mdraid_method_info_start =
{
  {
    -1,
    (gchar *) "Start",
    (GDBusArgInfo **) &_udisks_mdraid_method_info_start_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-start",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_mdraid_method_info_stop_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_mdraid_method_info_stop_IN_ARG_pointers[] =
{
  &_udisks_mdraid_method_info_stop_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_mdraid_method_info_stop =
{
  {
    -1,
    (gchar *) "Stop",
    (GDBusArgInfo **) &_udisks_mdraid_method_info_stop_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-stop",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_mdraid_method_info_remove_device_IN_ARG_device =
{
  {
    -1,
    (gchar *) "device",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_mdraid_method_info_remove_device_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_mdraid_method_info_remove_device_IN_ARG_pointers[] =
{
  &_udisks_mdraid_method_info_remove_device_IN_ARG_device.parent_struct,
  &_udisks_mdraid_method_info_remove_device_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_mdraid_method_info_remove_device =
{
  {
    -1,
    (gchar *) "RemoveDevice",
    (GDBusArgInfo **) &_udisks_mdraid_method_info_remove_device_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-remove-device",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_mdraid_method_info_add_device_IN_ARG_device =
{
  {
    -1,
    (gchar *) "device",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_mdraid_method_info_add_device_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_mdraid_method_info_add_device_IN_ARG_pointers[] =
{
  &_udisks_mdraid_method_info_add_device_IN_ARG_device.parent_struct,
  &_udisks_mdraid_method_info_add_device_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_mdraid_method_info_add_device =
{
  {
    -1,
    (gchar *) "AddDevice",
    (GDBusArgInfo **) &_udisks_mdraid_method_info_add_device_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-add-device",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_mdraid_method_info_set_bitmap_location_IN_ARG_value =
{
  {
    -1,
    (gchar *) "value",
    (gchar *) "ay",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_mdraid_method_info_set_bitmap_location_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_mdraid_method_info_set_bitmap_location_IN_ARG_pointers[] =
{
  &_udisks_mdraid_method_info_set_bitmap_location_IN_ARG_value.parent_struct,
  &_udisks_mdraid_method_info_set_bitmap_location_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_mdraid_method_info_set_bitmap_location =
{
  {
    -1,
    (gchar *) "SetBitmapLocation",
    (GDBusArgInfo **) &_udisks_mdraid_method_info_set_bitmap_location_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-bitmap-location",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_mdraid_method_info_request_sync_action_IN_ARG_sync_action =
{
  {
    -1,
    (gchar *) "sync_action",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_mdraid_method_info_request_sync_action_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_mdraid_method_info_request_sync_action_IN_ARG_pointers[] =
{
  &_udisks_mdraid_method_info_request_sync_action_IN_ARG_sync_action.parent_struct,
  &_udisks_mdraid_method_info_request_sync_action_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_mdraid_method_info_request_sync_action =
{
  {
    -1,
    (gchar *) "RequestSyncAction",
    (GDBusArgInfo **) &_udisks_mdraid_method_info_request_sync_action_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-request-sync-action",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_mdraid_method_info_delete_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_mdraid_method_info_delete_IN_ARG_pointers[] =
{
  &_udisks_mdraid_method_info_delete_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_mdraid_method_info_delete =
{
  {
    -1,
    (gchar *) "Delete",
    (GDBusArgInfo **) &_udisks_mdraid_method_info_delete_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-delete",
  FALSE
};

static const GDBusMethodInfo * const _udisks_mdraid_method_info_pointers[] =
{
  &_udisks_mdraid_method_info_start.parent_struct,
  &_udisks_mdraid_method_info_stop.parent_struct,
  &_udisks_mdraid_method_info_remove_device.parent_struct,
  &_udisks_mdraid_method_info_add_device.parent_struct,
  &_udisks_mdraid_method_info_set_bitmap_location.parent_struct,
  &_udisks_mdraid_method_info_request_sync_action.parent_struct,
  &_udisks_mdraid_method_info_delete.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_uuid =
{
  {
    -1,
    (gchar *) "UUID",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "uuid",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_name =
{
  {
    -1,
    (gchar *) "Name",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "name",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_level =
{
  {
    -1,
    (gchar *) "Level",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "level",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_num_devices =
{
  {
    -1,
    (gchar *) "NumDevices",
    (gchar *) "u",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "num-devices",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_size =
{
  {
    -1,
    (gchar *) "Size",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "size",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_sync_action =
{
  {
    -1,
    (gchar *) "SyncAction",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "sync-action",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_sync_completed =
{
  {
    -1,
    (gchar *) "SyncCompleted",
    (gchar *) "d",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "sync-completed",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_sync_rate =
{
  {
    -1,
    (gchar *) "SyncRate",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "sync-rate",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_sync_remaining_time =
{
  {
    -1,
    (gchar *) "SyncRemainingTime",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "sync-remaining-time",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_degraded =
{
  {
    -1,
    (gchar *) "Degraded",
    (gchar *) "u",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "degraded",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_consistency_policy =
{
  {
    -1,
    (gchar *) "ConsistencyPolicy",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "consistency-policy",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_bitmap_location =
{
  {
    -1,
    (gchar *) "BitmapLocation",
    (gchar *) "ay",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "bitmap-location",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_chunk_size =
{
  {
    -1,
    (gchar *) "ChunkSize",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "chunk-size",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_active_devices =
{
  {
    -1,
    (gchar *) "ActiveDevices",
    (gchar *) "a(oiasta{sv})",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "active-devices",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_child_configuration =
{
  {
    -1,
    (gchar *) "ChildConfiguration",
    (gchar *) "a(sa{sv})",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "child-configuration",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_mdraid_property_info_running =
{
  {
    -1,
    (gchar *) "Running",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "running",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_mdraid_property_info_pointers[] =
{
  &_udisks_mdraid_property_info_uuid.parent_struct,
  &_udisks_mdraid_property_info_name.parent_struct,
  &_udisks_mdraid_property_info_level.parent_struct,
  &_udisks_mdraid_property_info_num_devices.parent_struct,
  &_udisks_mdraid_property_info_size.parent_struct,
  &_udisks_mdraid_property_info_sync_action.parent_struct,
  &_udisks_mdraid_property_info_sync_completed.parent_struct,
  &_udisks_mdraid_property_info_sync_rate.parent_struct,
  &_udisks_mdraid_property_info_sync_remaining_time.parent_struct,
  &_udisks_mdraid_property_info_degraded.parent_struct,
  &_udisks_mdraid_property_info_consistency_policy.parent_struct,
  &_udisks_mdraid_property_info_bitmap_location.parent_struct,
  &_udisks_mdraid_property_info_chunk_size.parent_struct,
  &_udisks_mdraid_property_info_active_devices.parent_struct,
  &_udisks_mdraid_property_info_child_configuration.parent_struct,
  &_udisks_mdraid_property_info_running.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_mdraid_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.MDRaid",
    (GDBusMethodInfo **) &_udisks_mdraid_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_mdraid_property_info_pointers,
    NULL
  },
  "mdraid",
};


/**
 * udisks_mdraid_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-MDRaid.top_of_page">org.freedesktop.UDisks2.MDRaid</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 *
 * Since: 2.0.0
 */
GDBusInterfaceInfo *
udisks_mdraid_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_mdraid_interface_info.parent_struct;
}

/**
 * udisks_mdraid_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksMDRaid interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 *
 * Since: 2.0.0
 */
guint
udisks_mdraid_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "uuid");
  g_object_class_override_property (klass, property_id_begin++, "name");
  g_object_class_override_property (klass, property_id_begin++, "level");
  g_object_class_override_property (klass, property_id_begin++, "num-devices");
  g_object_class_override_property (klass, property_id_begin++, "size");
  g_object_class_override_property (klass, property_id_begin++, "sync-action");
  g_object_class_override_property (klass, property_id_begin++, "sync-completed");
  g_object_class_override_property (klass, property_id_begin++, "sync-rate");
  g_object_class_override_property (klass, property_id_begin++, "sync-remaining-time");
  g_object_class_override_property (klass, property_id_begin++, "degraded");
  g_object_class_override_property (klass, property_id_begin++, "consistency-policy");
  g_object_class_override_property (klass, property_id_begin++, "bitmap-location");
  g_object_class_override_property (klass, property_id_begin++, "chunk-size");
  g_object_class_override_property (klass, property_id_begin++, "active-devices");
  g_object_class_override_property (klass, property_id_begin++, "child-configuration");
  g_object_class_override_property (klass, property_id_begin++, "running");
  return property_id_begin - 1;
}


inline static void
udisks_mdraid_method_marshal_start (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_mdraid_method_marshal_stop (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_mdraid_method_marshal_remove_device (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_mdraid_method_marshal_add_device (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_mdraid_method_marshal_set_bitmap_location (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_mdraid_method_marshal_request_sync_action (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_mdraid_method_marshal_delete (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksMDRaid:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-MDRaid.top_of_page">org.freedesktop.UDisks2.MDRaid</link>.
 *
 * Since: 2.0.0
 */

/**
 * UDisksMDRaidIface:
 * @parent_iface: The parent interface.
 * @handle_add_device: Handler for the #UDisksMDRaid::handle-add-device signal.
 * @handle_delete: Handler for the #UDisksMDRaid::handle-delete signal.
 * @handle_remove_device: Handler for the #UDisksMDRaid::handle-remove-device signal.
 * @handle_request_sync_action: Handler for the #UDisksMDRaid::handle-request-sync-action signal.
 * @handle_set_bitmap_location: Handler for the #UDisksMDRaid::handle-set-bitmap-location signal.
 * @handle_start: Handler for the #UDisksMDRaid::handle-start signal.
 * @handle_stop: Handler for the #UDisksMDRaid::handle-stop signal.
 * @get_active_devices: Getter for the #UDisksMDRaid:active-devices property.
 * @get_bitmap_location: Getter for the #UDisksMDRaid:bitmap-location property.
 * @get_child_configuration: Getter for the #UDisksMDRaid:child-configuration property.
 * @get_chunk_size: Getter for the #UDisksMDRaid:chunk-size property.
 * @get_consistency_policy: Getter for the #UDisksMDRaid:consistency-policy property.
 * @get_degraded: Getter for the #UDisksMDRaid:degraded property.
 * @get_level: Getter for the #UDisksMDRaid:level property.
 * @get_name: Getter for the #UDisksMDRaid:name property.
 * @get_num_devices: Getter for the #UDisksMDRaid:num-devices property.
 * @get_running: Getter for the #UDisksMDRaid:running property.
 * @get_size: Getter for the #UDisksMDRaid:size property.
 * @get_sync_action: Getter for the #UDisksMDRaid:sync-action property.
 * @get_sync_completed: Getter for the #UDisksMDRaid:sync-completed property.
 * @get_sync_rate: Getter for the #UDisksMDRaid:sync-rate property.
 * @get_sync_remaining_time: Getter for the #UDisksMDRaid:sync-remaining-time property.
 * @get_uuid: Getter for the #UDisksMDRaid:uuid property.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-MDRaid.top_of_page">org.freedesktop.UDisks2.MDRaid</link>.
 *
 * Since: 2.0.0
 */

typedef UDisksMDRaidIface UDisksMDRaidInterface;
G_DEFINE_INTERFACE (UDisksMDRaid, udisks_mdraid, G_TYPE_OBJECT)

static void
udisks_mdraid_default_init (UDisksMDRaidIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksMDRaid::handle-start:
   * @object: A #UDisksMDRaid.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.Start">Start()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_mdraid_complete_start() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-start",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksMDRaidIface, handle_start),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_mdraid_method_marshal_start,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksMDRaid::handle-stop:
   * @object: A #UDisksMDRaid.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.Stop">Stop()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_mdraid_complete_stop() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-stop",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksMDRaidIface, handle_stop),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_mdraid_method_marshal_stop,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksMDRaid::handle-remove-device:
   * @object: A #UDisksMDRaid.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_device: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.RemoveDevice">RemoveDevice()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_mdraid_complete_remove_device() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-remove-device",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksMDRaidIface, handle_remove_device),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_mdraid_method_marshal_remove_device,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksMDRaid::handle-add-device:
   * @object: A #UDisksMDRaid.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_device: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.AddDevice">AddDevice()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_mdraid_complete_add_device() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-add-device",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksMDRaidIface, handle_add_device),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_mdraid_method_marshal_add_device,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksMDRaid::handle-set-bitmap-location:
   * @object: A #UDisksMDRaid.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_value: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.SetBitmapLocation">SetBitmapLocation()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_mdraid_complete_set_bitmap_location() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-set-bitmap-location",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksMDRaidIface, handle_set_bitmap_location),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_mdraid_method_marshal_set_bitmap_location,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksMDRaid::handle-request-sync-action:
   * @object: A #UDisksMDRaid.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_sync_action: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.RequestSyncAction">RequestSyncAction()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_mdraid_complete_request_sync_action() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-request-sync-action",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksMDRaidIface, handle_request_sync_action),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_mdraid_method_marshal_request_sync_action,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksMDRaid::handle-delete:
   * @object: A #UDisksMDRaid.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.Delete">Delete()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_mdraid_complete_delete() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-delete",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksMDRaidIface, handle_delete),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_mdraid_method_marshal_delete,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksMDRaid:uuid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.UUID">"UUID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("uuid", "UUID", "UUID", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:name:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Name">"Name"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("name", "Name", "Name", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:level:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Level">"Level"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("level", "Level", "Level", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:num-devices:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.NumDevices">"NumDevices"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint ("num-devices", "NumDevices", "NumDevices", 0, G_MAXUINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Size">"Size"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("size", "Size", "Size", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:sync-action:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.SyncAction">"SyncAction"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("sync-action", "SyncAction", "SyncAction", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:sync-completed:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.SyncCompleted">"SyncCompleted"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_double ("sync-completed", "SyncCompleted", "SyncCompleted", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:sync-rate:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.SyncRate">"SyncRate"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("sync-rate", "SyncRate", "SyncRate", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:sync-remaining-time:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.SyncRemainingTime">"SyncRemainingTime"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("sync-remaining-time", "SyncRemainingTime", "SyncRemainingTime", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:degraded:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Degraded">"Degraded"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint ("degraded", "Degraded", "Degraded", 0, G_MAXUINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:consistency-policy:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ConsistencyPolicy">"ConsistencyPolicy"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("consistency-policy", "ConsistencyPolicy", "ConsistencyPolicy", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:bitmap-location:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.BitmapLocation">"BitmapLocation"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("bitmap-location", "BitmapLocation", "BitmapLocation", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:chunk-size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ChunkSize">"ChunkSize"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("chunk-size", "ChunkSize", "ChunkSize", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:active-devices:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ActiveDevices">"ActiveDevices"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_variant ("active-devices", "ActiveDevices", "ActiveDevices", G_VARIANT_TYPE ("a(oiasta{sv})"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:child-configuration:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ChildConfiguration">"ChildConfiguration"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_variant ("child-configuration", "ChildConfiguration", "ChildConfiguration", G_VARIANT_TYPE ("a(sa{sv})"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksMDRaid:running:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Running">"Running"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("running", "Running", "Running", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_mdraid_get_uuid: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.UUID">"UUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_mdraid_dup_uuid() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_mdraid_get_uuid (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), NULL);

  return UDISKS_MDRAID_GET_IFACE (object)->get_uuid (object);
}

/**
 * udisks_mdraid_dup_uuid: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.UUID">"UUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_mdraid_dup_uuid (UDisksMDRaid *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "uuid", &value, NULL);
  return value;
}

/**
 * udisks_mdraid_set_uuid: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.UUID">"UUID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_uuid (UDisksMDRaid *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "uuid", value, NULL);
}

/**
 * udisks_mdraid_get_name: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Name">"Name"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_mdraid_dup_name() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_mdraid_get_name (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), NULL);

  return UDISKS_MDRAID_GET_IFACE (object)->get_name (object);
}

/**
 * udisks_mdraid_dup_name: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Name">"Name"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_mdraid_dup_name (UDisksMDRaid *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "name", &value, NULL);
  return value;
}

/**
 * udisks_mdraid_set_name: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Name">"Name"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_name (UDisksMDRaid *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "name", value, NULL);
}

/**
 * udisks_mdraid_get_level: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Level">"Level"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_mdraid_dup_level() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_mdraid_get_level (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), NULL);

  return UDISKS_MDRAID_GET_IFACE (object)->get_level (object);
}

/**
 * udisks_mdraid_dup_level: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Level">"Level"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_mdraid_dup_level (UDisksMDRaid *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "level", &value, NULL);
  return value;
}

/**
 * udisks_mdraid_set_level: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Level">"Level"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_level (UDisksMDRaid *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "level", value, NULL);
}

/**
 * udisks_mdraid_get_num_devices: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.NumDevices">"NumDevices"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
guint 
udisks_mdraid_get_num_devices (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), 0);

  return UDISKS_MDRAID_GET_IFACE (object)->get_num_devices (object);
}

/**
 * udisks_mdraid_set_num_devices: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.NumDevices">"NumDevices"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_num_devices (UDisksMDRaid *object, guint value)
{
  g_object_set (G_OBJECT (object), "num-devices", value, NULL);
}

/**
 * udisks_mdraid_get_size: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Size">"Size"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
guint64 
udisks_mdraid_get_size (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), 0);

  return UDISKS_MDRAID_GET_IFACE (object)->get_size (object);
}

/**
 * udisks_mdraid_set_size: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Size">"Size"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_size (UDisksMDRaid *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "size", value, NULL);
}

/**
 * udisks_mdraid_get_sync_action: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.SyncAction">"SyncAction"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_mdraid_dup_sync_action() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_mdraid_get_sync_action (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), NULL);

  return UDISKS_MDRAID_GET_IFACE (object)->get_sync_action (object);
}

/**
 * udisks_mdraid_dup_sync_action: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.SyncAction">"SyncAction"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_mdraid_dup_sync_action (UDisksMDRaid *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "sync-action", &value, NULL);
  return value;
}

/**
 * udisks_mdraid_set_sync_action: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.SyncAction">"SyncAction"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_sync_action (UDisksMDRaid *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "sync-action", value, NULL);
}

/**
 * udisks_mdraid_get_sync_completed: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.SyncCompleted">"SyncCompleted"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
gdouble 
udisks_mdraid_get_sync_completed (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), 0.0);

  return UDISKS_MDRAID_GET_IFACE (object)->get_sync_completed (object);
}

/**
 * udisks_mdraid_set_sync_completed: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.SyncCompleted">"SyncCompleted"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_sync_completed (UDisksMDRaid *object, gdouble value)
{
  g_object_set (G_OBJECT (object), "sync-completed", value, NULL);
}

/**
 * udisks_mdraid_get_sync_rate: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.SyncRate">"SyncRate"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
guint64 
udisks_mdraid_get_sync_rate (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), 0);

  return UDISKS_MDRAID_GET_IFACE (object)->get_sync_rate (object);
}

/**
 * udisks_mdraid_set_sync_rate: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.SyncRate">"SyncRate"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_sync_rate (UDisksMDRaid *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "sync-rate", value, NULL);
}

/**
 * udisks_mdraid_get_sync_remaining_time: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.SyncRemainingTime">"SyncRemainingTime"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
guint64 
udisks_mdraid_get_sync_remaining_time (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), 0);

  return UDISKS_MDRAID_GET_IFACE (object)->get_sync_remaining_time (object);
}

/**
 * udisks_mdraid_set_sync_remaining_time: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.SyncRemainingTime">"SyncRemainingTime"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_sync_remaining_time (UDisksMDRaid *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "sync-remaining-time", value, NULL);
}

/**
 * udisks_mdraid_get_degraded: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Degraded">"Degraded"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
guint 
udisks_mdraid_get_degraded (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), 0);

  return UDISKS_MDRAID_GET_IFACE (object)->get_degraded (object);
}

/**
 * udisks_mdraid_set_degraded: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Degraded">"Degraded"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_degraded (UDisksMDRaid *object, guint value)
{
  g_object_set (G_OBJECT (object), "degraded", value, NULL);
}

/**
 * udisks_mdraid_get_consistency_policy: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ConsistencyPolicy">"ConsistencyPolicy"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_mdraid_dup_consistency_policy() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_mdraid_get_consistency_policy (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), NULL);

  return UDISKS_MDRAID_GET_IFACE (object)->get_consistency_policy (object);
}

/**
 * udisks_mdraid_dup_consistency_policy: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ConsistencyPolicy">"ConsistencyPolicy"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_mdraid_dup_consistency_policy (UDisksMDRaid *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "consistency-policy", &value, NULL);
  return value;
}

/**
 * udisks_mdraid_set_consistency_policy: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ConsistencyPolicy">"ConsistencyPolicy"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_consistency_policy (UDisksMDRaid *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "consistency-policy", value, NULL);
}

/**
 * udisks_mdraid_get_bitmap_location: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.BitmapLocation">"BitmapLocation"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_mdraid_dup_bitmap_location() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_mdraid_get_bitmap_location (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), NULL);

  return UDISKS_MDRAID_GET_IFACE (object)->get_bitmap_location (object);
}

/**
 * udisks_mdraid_dup_bitmap_location: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.BitmapLocation">"BitmapLocation"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_mdraid_dup_bitmap_location (UDisksMDRaid *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "bitmap-location", &value, NULL);
  return value;
}

/**
 * udisks_mdraid_set_bitmap_location: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.BitmapLocation">"BitmapLocation"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_bitmap_location (UDisksMDRaid *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "bitmap-location", value, NULL);
}

/**
 * udisks_mdraid_get_chunk_size: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ChunkSize">"ChunkSize"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
guint64 
udisks_mdraid_get_chunk_size (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), 0);

  return UDISKS_MDRAID_GET_IFACE (object)->get_chunk_size (object);
}

/**
 * udisks_mdraid_set_chunk_size: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ChunkSize">"ChunkSize"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_chunk_size (UDisksMDRaid *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "chunk-size", value, NULL);
}

/**
 * udisks_mdraid_get_active_devices: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ActiveDevices">"ActiveDevices"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_mdraid_dup_active_devices() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
GVariant *
udisks_mdraid_get_active_devices (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), NULL);

  return UDISKS_MDRAID_GET_IFACE (object)->get_active_devices (object);
}

/**
 * udisks_mdraid_dup_active_devices: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ActiveDevices">"ActiveDevices"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_variant_unref().
 *
 * Since: 2.0.0
 */
GVariant *
udisks_mdraid_dup_active_devices (UDisksMDRaid *object)
{
  GVariant *value;
  g_object_get (G_OBJECT (object), "active-devices", &value, NULL);
  return value;
}

/**
 * udisks_mdraid_set_active_devices: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ActiveDevices">"ActiveDevices"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_active_devices (UDisksMDRaid *object, GVariant *value)
{
  g_object_set (G_OBJECT (object), "active-devices", value, NULL);
}

/**
 * udisks_mdraid_get_child_configuration: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ChildConfiguration">"ChildConfiguration"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_mdraid_dup_child_configuration() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
GVariant *
udisks_mdraid_get_child_configuration (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), NULL);

  return UDISKS_MDRAID_GET_IFACE (object)->get_child_configuration (object);
}

/**
 * udisks_mdraid_dup_child_configuration: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ChildConfiguration">"ChildConfiguration"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_variant_unref().
 *
 * Since: 2.0.0
 */
GVariant *
udisks_mdraid_dup_child_configuration (UDisksMDRaid *object)
{
  GVariant *value;
  g_object_get (G_OBJECT (object), "child-configuration", &value, NULL);
  return value;
}

/**
 * udisks_mdraid_set_child_configuration: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.ChildConfiguration">"ChildConfiguration"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_child_configuration (UDisksMDRaid *object, GVariant *value)
{
  g_object_set (G_OBJECT (object), "child-configuration", value, NULL);
}

/**
 * udisks_mdraid_get_running: (skip)
 * @object: A #UDisksMDRaid.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Running">"Running"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
gboolean 
udisks_mdraid_get_running (UDisksMDRaid *object)
{
  g_return_val_if_fail (UDISKS_IS_MDRAID (object), FALSE);

  return UDISKS_MDRAID_GET_IFACE (object)->get_running (object);
}

/**
 * udisks_mdraid_set_running: (skip)
 * @object: A #UDisksMDRaid.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-MDRaid.Running">"Running"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_set_running (UDisksMDRaid *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "running", value, NULL);
}

/**
 * udisks_mdraid_call_start:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.Start">Start()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_mdraid_call_start_finish() to get the result of the operation.
 *
 * See udisks_mdraid_call_start_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_call_start (
    UDisksMDRaid *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Start",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_mdraid_call_start_finish:
 * @proxy: A #UDisksMDRaidProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_mdraid_call_start().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_mdraid_call_start().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_start_finish (
    UDisksMDRaid *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_call_start_sync:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.Start">Start()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_mdraid_call_start() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_start_sync (
    UDisksMDRaid *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Start",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_call_stop:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.Stop">Stop()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_mdraid_call_stop_finish() to get the result of the operation.
 *
 * See udisks_mdraid_call_stop_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_call_stop (
    UDisksMDRaid *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Stop",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_mdraid_call_stop_finish:
 * @proxy: A #UDisksMDRaidProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_mdraid_call_stop().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_mdraid_call_stop().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_stop_finish (
    UDisksMDRaid *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_call_stop_sync:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.Stop">Stop()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_mdraid_call_stop() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_stop_sync (
    UDisksMDRaid *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Stop",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_call_remove_device:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_device: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.RemoveDevice">RemoveDevice()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_mdraid_call_remove_device_finish() to get the result of the operation.
 *
 * See udisks_mdraid_call_remove_device_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_call_remove_device (
    UDisksMDRaid *proxy,
    const gchar *arg_device,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "RemoveDevice",
    g_variant_new ("(o@a{sv})",
                   arg_device,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_mdraid_call_remove_device_finish:
 * @proxy: A #UDisksMDRaidProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_mdraid_call_remove_device().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_mdraid_call_remove_device().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_remove_device_finish (
    UDisksMDRaid *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_call_remove_device_sync:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_device: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.RemoveDevice">RemoveDevice()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_mdraid_call_remove_device() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_remove_device_sync (
    UDisksMDRaid *proxy,
    const gchar *arg_device,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "RemoveDevice",
    g_variant_new ("(o@a{sv})",
                   arg_device,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_call_add_device:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_device: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.AddDevice">AddDevice()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_mdraid_call_add_device_finish() to get the result of the operation.
 *
 * See udisks_mdraid_call_add_device_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_call_add_device (
    UDisksMDRaid *proxy,
    const gchar *arg_device,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "AddDevice",
    g_variant_new ("(o@a{sv})",
                   arg_device,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_mdraid_call_add_device_finish:
 * @proxy: A #UDisksMDRaidProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_mdraid_call_add_device().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_mdraid_call_add_device().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_add_device_finish (
    UDisksMDRaid *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_call_add_device_sync:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_device: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.AddDevice">AddDevice()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_mdraid_call_add_device() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_add_device_sync (
    UDisksMDRaid *proxy,
    const gchar *arg_device,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "AddDevice",
    g_variant_new ("(o@a{sv})",
                   arg_device,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_call_set_bitmap_location:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_value: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.SetBitmapLocation">SetBitmapLocation()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_mdraid_call_set_bitmap_location_finish() to get the result of the operation.
 *
 * See udisks_mdraid_call_set_bitmap_location_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_call_set_bitmap_location (
    UDisksMDRaid *proxy,
    const gchar *arg_value,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetBitmapLocation",
    g_variant_new ("(^ay@a{sv})",
                   arg_value,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_mdraid_call_set_bitmap_location_finish:
 * @proxy: A #UDisksMDRaidProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_mdraid_call_set_bitmap_location().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_mdraid_call_set_bitmap_location().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_set_bitmap_location_finish (
    UDisksMDRaid *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_call_set_bitmap_location_sync:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_value: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.SetBitmapLocation">SetBitmapLocation()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_mdraid_call_set_bitmap_location() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_set_bitmap_location_sync (
    UDisksMDRaid *proxy,
    const gchar *arg_value,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetBitmapLocation",
    g_variant_new ("(^ay@a{sv})",
                   arg_value,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_call_request_sync_action:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_sync_action: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.RequestSyncAction">RequestSyncAction()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_mdraid_call_request_sync_action_finish() to get the result of the operation.
 *
 * See udisks_mdraid_call_request_sync_action_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_call_request_sync_action (
    UDisksMDRaid *proxy,
    const gchar *arg_sync_action,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "RequestSyncAction",
    g_variant_new ("(s@a{sv})",
                   arg_sync_action,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_mdraid_call_request_sync_action_finish:
 * @proxy: A #UDisksMDRaidProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_mdraid_call_request_sync_action().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_mdraid_call_request_sync_action().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_request_sync_action_finish (
    UDisksMDRaid *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_call_request_sync_action_sync:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_sync_action: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.RequestSyncAction">RequestSyncAction()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_mdraid_call_request_sync_action() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_request_sync_action_sync (
    UDisksMDRaid *proxy,
    const gchar *arg_sync_action,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "RequestSyncAction",
    g_variant_new ("(s@a{sv})",
                   arg_sync_action,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_call_delete:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.Delete">Delete()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_mdraid_call_delete_finish() to get the result of the operation.
 *
 * See udisks_mdraid_call_delete_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_call_delete (
    UDisksMDRaid *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Delete",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_mdraid_call_delete_finish:
 * @proxy: A #UDisksMDRaidProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_mdraid_call_delete().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_mdraid_call_delete().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_delete_finish (
    UDisksMDRaid *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_call_delete_sync:
 * @proxy: A #UDisksMDRaidProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.Delete">Delete()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_mdraid_call_delete() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_mdraid_call_delete_sync (
    UDisksMDRaid *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Delete",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_mdraid_complete_start:
 * @object: A #UDisksMDRaid.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.Start">Start()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_complete_start (
    UDisksMDRaid *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_mdraid_complete_stop:
 * @object: A #UDisksMDRaid.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.Stop">Stop()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_complete_stop (
    UDisksMDRaid *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_mdraid_complete_remove_device:
 * @object: A #UDisksMDRaid.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.RemoveDevice">RemoveDevice()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_complete_remove_device (
    UDisksMDRaid *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_mdraid_complete_add_device:
 * @object: A #UDisksMDRaid.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.AddDevice">AddDevice()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_complete_add_device (
    UDisksMDRaid *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_mdraid_complete_set_bitmap_location:
 * @object: A #UDisksMDRaid.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.SetBitmapLocation">SetBitmapLocation()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_complete_set_bitmap_location (
    UDisksMDRaid *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_mdraid_complete_request_sync_action:
 * @object: A #UDisksMDRaid.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.RequestSyncAction">RequestSyncAction()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_complete_request_sync_action (
    UDisksMDRaid *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_mdraid_complete_delete:
 * @object: A #UDisksMDRaid.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-MDRaid.Delete">Delete()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_complete_delete (
    UDisksMDRaid *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksMDRaidProxy:
 *
 * The #UDisksMDRaidProxy structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.0.0
 */

/**
 * UDisksMDRaidProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksMDRaidProxy.
 *
 * Since: 2.0.0
 */

struct _UDisksMDRaidProxyPrivate
{
  GData *qdata;
};

static void udisks_mdraid_proxy_iface_init (UDisksMDRaidIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksMDRaidProxy, udisks_mdraid_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksMDRaidProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MDRAID, udisks_mdraid_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksMDRaidProxy, udisks_mdraid_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MDRAID, udisks_mdraid_proxy_iface_init))

#endif
static void
udisks_mdraid_proxy_finalize (GObject *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_mdraid_proxy_parent_class)->finalize (object);
}

static void
udisks_mdraid_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 16);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_mdraid_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_mdraid_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.MDRaid: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_mdraid_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 16);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_mdraid_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.MDRaid", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_mdraid_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_mdraid_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_mdraid_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_MDRAID);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_MDRAID);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_mdraid_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_mdraid_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_mdraid_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_mdraid_proxy_get_uuid (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "UUID");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_mdraid_proxy_get_name (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Name");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_mdraid_proxy_get_level (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Level");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static guint 
udisks_mdraid_proxy_get_num_devices (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  guint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "NumDevices");
  if (variant != NULL)
    {
      value = g_variant_get_uint32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_mdraid_proxy_get_size (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Size");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_mdraid_proxy_get_sync_action (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SyncAction");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static gdouble 
udisks_mdraid_proxy_get_sync_completed (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  gdouble value = 0.0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SyncCompleted");
  if (variant != NULL)
    {
      value = g_variant_get_double (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_mdraid_proxy_get_sync_rate (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SyncRate");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_mdraid_proxy_get_sync_remaining_time (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SyncRemainingTime");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint 
udisks_mdraid_proxy_get_degraded (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  guint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Degraded");
  if (variant != NULL)
    {
      value = g_variant_get_uint32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_mdraid_proxy_get_consistency_policy (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ConsistencyPolicy");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_mdraid_proxy_get_bitmap_location (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "BitmapLocation");
  if (variant != NULL)
    {
      value = g_variant_get_bytestring (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_mdraid_proxy_get_chunk_size (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ChunkSize");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static GVariant *
udisks_mdraid_proxy_get_active_devices (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  GVariant *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ActiveDevices");
  value = variant;
  if (variant != NULL)
    g_variant_unref (variant);
  return value;
}

static GVariant *
udisks_mdraid_proxy_get_child_configuration (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  GVariant *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ChildConfiguration");
  value = variant;
  if (variant != NULL)
    g_variant_unref (variant);
  return value;
}

static gboolean 
udisks_mdraid_proxy_get_running (UDisksMDRaid *object)
{
  UDisksMDRaidProxy *proxy = UDISKS_MDRAID_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Running");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_mdraid_proxy_init (UDisksMDRaidProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_mdraid_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_MDRAID_PROXY, UDisksMDRaidProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_mdraid_interface_info ());
}

static void
udisks_mdraid_proxy_class_init (UDisksMDRaidProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_mdraid_proxy_finalize;
  gobject_class->get_property = udisks_mdraid_proxy_get_property;
  gobject_class->set_property = udisks_mdraid_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_mdraid_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_mdraid_proxy_g_properties_changed;

  udisks_mdraid_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksMDRaidProxyPrivate));
#endif
}

static void
udisks_mdraid_proxy_iface_init (UDisksMDRaidIface *iface)
{
  iface->get_uuid = udisks_mdraid_proxy_get_uuid;
  iface->get_name = udisks_mdraid_proxy_get_name;
  iface->get_level = udisks_mdraid_proxy_get_level;
  iface->get_num_devices = udisks_mdraid_proxy_get_num_devices;
  iface->get_size = udisks_mdraid_proxy_get_size;
  iface->get_sync_action = udisks_mdraid_proxy_get_sync_action;
  iface->get_sync_completed = udisks_mdraid_proxy_get_sync_completed;
  iface->get_sync_rate = udisks_mdraid_proxy_get_sync_rate;
  iface->get_sync_remaining_time = udisks_mdraid_proxy_get_sync_remaining_time;
  iface->get_degraded = udisks_mdraid_proxy_get_degraded;
  iface->get_consistency_policy = udisks_mdraid_proxy_get_consistency_policy;
  iface->get_bitmap_location = udisks_mdraid_proxy_get_bitmap_location;
  iface->get_chunk_size = udisks_mdraid_proxy_get_chunk_size;
  iface->get_active_devices = udisks_mdraid_proxy_get_active_devices;
  iface->get_child_configuration = udisks_mdraid_proxy_get_child_configuration;
  iface->get_running = udisks_mdraid_proxy_get_running;
}

/**
 * udisks_mdraid_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-MDRaid.top_of_page">org.freedesktop.UDisks2.MDRaid</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_mdraid_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_mdraid_proxy_new_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_MDRAID_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.MDRaid", NULL);
}

/**
 * udisks_mdraid_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_mdraid_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_mdraid_proxy_new().
 *
 * Returns: (transfer full) (type UDisksMDRaidProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksMDRaid *
udisks_mdraid_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_MDRAID (ret);
  else
    return NULL;
}

/**
 * udisks_mdraid_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-MDRaid.top_of_page">org.freedesktop.UDisks2.MDRaid</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_mdraid_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksMDRaidProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksMDRaid *
udisks_mdraid_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_MDRAID_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.MDRaid", NULL);
  if (ret != NULL)
    return UDISKS_MDRAID (ret);
  else
    return NULL;
}


/**
 * udisks_mdraid_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_mdraid_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_mdraid_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_mdraid_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.0.0
 */
void
udisks_mdraid_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_MDRAID_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.MDRaid", NULL);
}

/**
 * udisks_mdraid_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_mdraid_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_mdraid_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksMDRaidProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksMDRaid *
udisks_mdraid_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_MDRAID (ret);
  else
    return NULL;
}

/**
 * udisks_mdraid_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_mdraid_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_mdraid_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksMDRaidProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksMDRaid *
udisks_mdraid_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_MDRAID_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.MDRaid", NULL);
  if (ret != NULL)
    return UDISKS_MDRAID (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksMDRaidSkeleton:
 *
 * The #UDisksMDRaidSkeleton structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.0.0
 */

/**
 * UDisksMDRaidSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksMDRaidSkeleton.
 *
 * Since: 2.0.0
 */

struct _UDisksMDRaidSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_mdraid_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_MDRAID);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_MDRAID);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_mdraid_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_mdraid_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_mdraid_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_mdraid_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_mdraid_skeleton_vtable =
{
  _udisks_mdraid_skeleton_handle_method_call,
  _udisks_mdraid_skeleton_handle_get_property,
  _udisks_mdraid_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_mdraid_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_mdraid_interface_info ();
}

static GDBusInterfaceVTable *
udisks_mdraid_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_mdraid_skeleton_vtable;
}

static GVariant *
udisks_mdraid_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_mdraid_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_mdraid_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_mdraid_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_mdraid_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.MDRaid", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_mdraid_emit_changed (gpointer user_data);

static void
udisks_mdraid_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_mdraid_emit_changed (skeleton);
}

static void udisks_mdraid_skeleton_iface_init (UDisksMDRaidIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksMDRaidSkeleton, udisks_mdraid_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksMDRaidSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MDRAID, udisks_mdraid_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksMDRaidSkeleton, udisks_mdraid_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MDRAID, udisks_mdraid_skeleton_iface_init))

#endif
static void
udisks_mdraid_skeleton_finalize (GObject *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  guint n;
  for (n = 0; n < 16; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_mdraid_skeleton_parent_class)->finalize (object);
}

static void
udisks_mdraid_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 16);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_mdraid_emit_changed (gpointer user_data)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.MDRaid",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_mdraid_schedule_emit_changed (UDisksMDRaidSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_mdraid_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_mdraid_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_mdraid_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_mdraid_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 16);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_mdraid_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_mdraid_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_mdraid_skeleton_init (UDisksMDRaidSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_mdraid_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_MDRAID_SKELETON, UDisksMDRaidSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 16);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_UINT);
  g_value_init (&skeleton->priv->properties[4], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[5], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[6], G_TYPE_DOUBLE);
  g_value_init (&skeleton->priv->properties[7], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[8], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[9], G_TYPE_UINT);
  g_value_init (&skeleton->priv->properties[10], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[11], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[12], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[13], G_TYPE_VARIANT);
  g_value_init (&skeleton->priv->properties[14], G_TYPE_VARIANT);
  g_value_init (&skeleton->priv->properties[15], G_TYPE_BOOLEAN);
}

static const gchar *
udisks_mdraid_skeleton_get_uuid (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_mdraid_skeleton_get_name (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_mdraid_skeleton_get_level (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint 
udisks_mdraid_skeleton_get_num_devices (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  guint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_mdraid_skeleton_get_size (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[4]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_mdraid_skeleton_get_sync_action (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[5]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gdouble 
udisks_mdraid_skeleton_get_sync_completed (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  gdouble value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_double (&(skeleton->priv->properties[6]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_mdraid_skeleton_get_sync_rate (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[7]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_mdraid_skeleton_get_sync_remaining_time (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[8]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint 
udisks_mdraid_skeleton_get_degraded (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  guint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint (&(skeleton->priv->properties[9]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_mdraid_skeleton_get_consistency_policy (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[10]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_mdraid_skeleton_get_bitmap_location (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[11]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_mdraid_skeleton_get_chunk_size (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[12]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static GVariant *
udisks_mdraid_skeleton_get_active_devices (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  GVariant *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_variant (&(skeleton->priv->properties[13]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static GVariant *
udisks_mdraid_skeleton_get_child_configuration (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  GVariant *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_variant (&(skeleton->priv->properties[14]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_mdraid_skeleton_get_running (UDisksMDRaid *object)
{
  UDisksMDRaidSkeleton *skeleton = UDISKS_MDRAID_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[15]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_mdraid_skeleton_class_init (UDisksMDRaidSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_mdraid_skeleton_finalize;
  gobject_class->get_property = udisks_mdraid_skeleton_get_property;
  gobject_class->set_property = udisks_mdraid_skeleton_set_property;
  gobject_class->notify       = udisks_mdraid_skeleton_notify;


  udisks_mdraid_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_mdraid_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_mdraid_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_mdraid_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_mdraid_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksMDRaidSkeletonPrivate));
#endif
}

static void
udisks_mdraid_skeleton_iface_init (UDisksMDRaidIface *iface)
{
  iface->get_uuid = udisks_mdraid_skeleton_get_uuid;
  iface->get_name = udisks_mdraid_skeleton_get_name;
  iface->get_level = udisks_mdraid_skeleton_get_level;
  iface->get_num_devices = udisks_mdraid_skeleton_get_num_devices;
  iface->get_size = udisks_mdraid_skeleton_get_size;
  iface->get_sync_action = udisks_mdraid_skeleton_get_sync_action;
  iface->get_sync_completed = udisks_mdraid_skeleton_get_sync_completed;
  iface->get_sync_rate = udisks_mdraid_skeleton_get_sync_rate;
  iface->get_sync_remaining_time = udisks_mdraid_skeleton_get_sync_remaining_time;
  iface->get_degraded = udisks_mdraid_skeleton_get_degraded;
  iface->get_consistency_policy = udisks_mdraid_skeleton_get_consistency_policy;
  iface->get_bitmap_location = udisks_mdraid_skeleton_get_bitmap_location;
  iface->get_chunk_size = udisks_mdraid_skeleton_get_chunk_size;
  iface->get_active_devices = udisks_mdraid_skeleton_get_active_devices;
  iface->get_child_configuration = udisks_mdraid_skeleton_get_child_configuration;
  iface->get_running = udisks_mdraid_skeleton_get_running;
}

/**
 * udisks_mdraid_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-MDRaid.top_of_page">org.freedesktop.UDisks2.MDRaid</link>.
 *
 * Returns: (transfer full) (type UDisksMDRaidSkeleton): The skeleton object.
 *
 * Since: 2.0.0
 */
UDisksMDRaid *
udisks_mdraid_skeleton_new (void)
{
  return UDISKS_MDRAID (g_object_new (UDISKS_TYPE_MDRAID_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Job
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksJob
 * @title: UDisksJob
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Job D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Job.top_of_page">org.freedesktop.UDisks2.Job</link> D-Bus interface in C.
 */

enum
{
  UDISKS__JOB_COMPLETED,
};

static unsigned UDISKS__JOB_SIGNALS[1] = { 0 };

/* ---- Introspection data for org.freedesktop.UDisks2.Job ---- */

static const _ExtendedGDBusArgInfo _udisks_job_method_info_cancel_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_job_method_info_cancel_IN_ARG_pointers[] =
{
  &_udisks_job_method_info_cancel_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_job_method_info_cancel =
{
  {
    -1,
    (gchar *) "Cancel",
    (GDBusArgInfo **) &_udisks_job_method_info_cancel_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-cancel",
  FALSE
};

static const GDBusMethodInfo * const _udisks_job_method_info_pointers[] =
{
  &_udisks_job_method_info_cancel.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_job_signal_info_completed_ARG_success =
{
  {
    -1,
    (gchar *) "success",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_job_signal_info_completed_ARG_message =
{
  {
    -1,
    (gchar *) "message",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_job_signal_info_completed_ARG_pointers[] =
{
  &_udisks_job_signal_info_completed_ARG_success.parent_struct,
  &_udisks_job_signal_info_completed_ARG_message.parent_struct,
  NULL
};

static const _ExtendedGDBusSignalInfo _udisks_job_signal_info_completed =
{
  {
    -1,
    (gchar *) "Completed",
    (GDBusArgInfo **) &_udisks_job_signal_info_completed_ARG_pointers,
    NULL
  },
  "completed"
};

static const GDBusSignalInfo * const _udisks_job_signal_info_pointers[] =
{
  &_udisks_job_signal_info_completed.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_job_property_info_operation =
{
  {
    -1,
    (gchar *) "Operation",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "operation",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_job_property_info_progress =
{
  {
    -1,
    (gchar *) "Progress",
    (gchar *) "d",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "progress",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_job_property_info_progress_valid =
{
  {
    -1,
    (gchar *) "ProgressValid",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "progress-valid",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_job_property_info_bytes =
{
  {
    -1,
    (gchar *) "Bytes",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "bytes",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_job_property_info_rate =
{
  {
    -1,
    (gchar *) "Rate",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "rate",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_job_property_info_start_time =
{
  {
    -1,
    (gchar *) "StartTime",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "start-time",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_job_property_info_expected_end_time =
{
  {
    -1,
    (gchar *) "ExpectedEndTime",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "expected-end-time",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_job_property_info_objects =
{
  {
    -1,
    (gchar *) "Objects",
    (gchar *) "ao",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "objects",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_job_property_info_started_by_uid =
{
  {
    -1,
    (gchar *) "StartedByUID",
    (gchar *) "u",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "started-by-uid",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_job_property_info_cancelable =
{
  {
    -1,
    (gchar *) "Cancelable",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "cancelable",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_job_property_info_pointers[] =
{
  &_udisks_job_property_info_operation.parent_struct,
  &_udisks_job_property_info_progress.parent_struct,
  &_udisks_job_property_info_progress_valid.parent_struct,
  &_udisks_job_property_info_bytes.parent_struct,
  &_udisks_job_property_info_rate.parent_struct,
  &_udisks_job_property_info_start_time.parent_struct,
  &_udisks_job_property_info_expected_end_time.parent_struct,
  &_udisks_job_property_info_objects.parent_struct,
  &_udisks_job_property_info_started_by_uid.parent_struct,
  &_udisks_job_property_info_cancelable.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_job_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Job",
    (GDBusMethodInfo **) &_udisks_job_method_info_pointers,
    (GDBusSignalInfo **) &_udisks_job_signal_info_pointers,
    (GDBusPropertyInfo **) &_udisks_job_property_info_pointers,
    NULL
  },
  "job",
};


/**
 * udisks_job_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Job.top_of_page">org.freedesktop.UDisks2.Job</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 */
GDBusInterfaceInfo *
udisks_job_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_job_interface_info.parent_struct;
}

/**
 * udisks_job_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksJob interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 */
guint
udisks_job_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "operation");
  g_object_class_override_property (klass, property_id_begin++, "progress");
  g_object_class_override_property (klass, property_id_begin++, "progress-valid");
  g_object_class_override_property (klass, property_id_begin++, "bytes");
  g_object_class_override_property (klass, property_id_begin++, "rate");
  g_object_class_override_property (klass, property_id_begin++, "start-time");
  g_object_class_override_property (klass, property_id_begin++, "expected-end-time");
  g_object_class_override_property (klass, property_id_begin++, "objects");
  g_object_class_override_property (klass, property_id_begin++, "started-by-uid");
  g_object_class_override_property (klass, property_id_begin++, "cancelable");
  return property_id_begin - 1;
}


inline static void
udisks_job_signal_marshal_completed (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_VOID__BOOLEAN_STRING (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_job_method_marshal_cancel (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksJob:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Job.top_of_page">org.freedesktop.UDisks2.Job</link>.
 */

/**
 * UDisksJobIface:
 * @parent_iface: The parent interface.
 * @handle_cancel: Handler for the #UDisksJob::handle-cancel signal.
 * @get_bytes: Getter for the #UDisksJob:bytes property.
 * @get_cancelable: Getter for the #UDisksJob:cancelable property.
 * @get_expected_end_time: Getter for the #UDisksJob:expected-end-time property.
 * @get_objects: Getter for the #UDisksJob:objects property.
 * @get_operation: Getter for the #UDisksJob:operation property.
 * @get_progress: Getter for the #UDisksJob:progress property.
 * @get_progress_valid: Getter for the #UDisksJob:progress-valid property.
 * @get_rate: Getter for the #UDisksJob:rate property.
 * @get_start_time: Getter for the #UDisksJob:start-time property.
 * @get_started_by_uid: Getter for the #UDisksJob:started-by-uid property.
 * @completed: Handler for the #UDisksJob::completed signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Job.top_of_page">org.freedesktop.UDisks2.Job</link>.
 */

typedef UDisksJobIface UDisksJobInterface;
G_DEFINE_INTERFACE (UDisksJob, udisks_job, G_TYPE_OBJECT)

static void
udisks_job_default_init (UDisksJobIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksJob::handle-cancel:
   * @object: A #UDisksJob.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Job.Cancel">Cancel()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_job_complete_cancel() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   */
  g_signal_new ("handle-cancel",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksJobIface, handle_cancel),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_job_method_marshal_cancel,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /* GObject signals for received D-Bus signals: */
  /**
   * UDisksJob::completed:
   * @object: A #UDisksJob.
   * @arg_success: Argument.
   * @arg_message: Argument.
   *
   * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks2-Job.Completed">"Completed"</link> is received.
   *
   * On the service-side, this signal can be used with e.g. g_signal_emit_by_name() to make the object emit the D-Bus signal.
   */
  UDISKS__JOB_SIGNALS[UDISKS__JOB_COMPLETED] =
    g_signal_new ("completed",
      G_TYPE_FROM_INTERFACE (iface),
      G_SIGNAL_RUN_LAST,
      G_STRUCT_OFFSET (UDisksJobIface, completed),
      NULL,
      NULL,
      udisks_job_signal_marshal_completed,
      G_TYPE_NONE,
      2, G_TYPE_BOOLEAN, G_TYPE_STRING);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksJob:operation:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Operation">"Operation"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("operation", "Operation", "Operation", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksJob:progress:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Progress">"Progress"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_double ("progress", "Progress", "Progress", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksJob:progress-valid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.ProgressValid">"ProgressValid"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("progress-valid", "ProgressValid", "ProgressValid", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksJob:bytes:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Bytes">"Bytes"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("bytes", "Bytes", "Bytes", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksJob:rate:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Rate">"Rate"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("rate", "Rate", "Rate", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksJob:start-time:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.StartTime">"StartTime"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("start-time", "StartTime", "StartTime", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksJob:expected-end-time:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.ExpectedEndTime">"ExpectedEndTime"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("expected-end-time", "ExpectedEndTime", "ExpectedEndTime", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksJob:objects:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Objects">"Objects"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boxed ("objects", "Objects", "Objects", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksJob:started-by-uid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.StartedByUID">"StartedByUID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint ("started-by-uid", "StartedByUID", "StartedByUID", 0, G_MAXUINT32, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksJob:cancelable:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Cancelable">"Cancelable"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("cancelable", "Cancelable", "Cancelable", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_job_get_operation: (skip)
 * @object: A #UDisksJob.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Operation">"Operation"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_job_dup_operation() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *
udisks_job_get_operation (UDisksJob *object)
{
  g_return_val_if_fail (UDISKS_IS_JOB (object), NULL);

  return UDISKS_JOB_GET_IFACE (object)->get_operation (object);
}

/**
 * udisks_job_dup_operation: (skip)
 * @object: A #UDisksJob.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Operation">"Operation"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 */
gchar *
udisks_job_dup_operation (UDisksJob *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "operation", &value, NULL);
  return value;
}

/**
 * udisks_job_set_operation: (skip)
 * @object: A #UDisksJob.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Operation">"Operation"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_job_set_operation (UDisksJob *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "operation", value, NULL);
}

/**
 * udisks_job_get_progress: (skip)
 * @object: A #UDisksJob.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Progress">"Progress"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gdouble 
udisks_job_get_progress (UDisksJob *object)
{
  g_return_val_if_fail (UDISKS_IS_JOB (object), 0.0);

  return UDISKS_JOB_GET_IFACE (object)->get_progress (object);
}

/**
 * udisks_job_set_progress: (skip)
 * @object: A #UDisksJob.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Progress">"Progress"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_job_set_progress (UDisksJob *object, gdouble value)
{
  g_object_set (G_OBJECT (object), "progress", value, NULL);
}

/**
 * udisks_job_get_progress_valid: (skip)
 * @object: A #UDisksJob.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.ProgressValid">"ProgressValid"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_job_get_progress_valid (UDisksJob *object)
{
  g_return_val_if_fail (UDISKS_IS_JOB (object), FALSE);

  return UDISKS_JOB_GET_IFACE (object)->get_progress_valid (object);
}

/**
 * udisks_job_set_progress_valid: (skip)
 * @object: A #UDisksJob.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.ProgressValid">"ProgressValid"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_job_set_progress_valid (UDisksJob *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "progress-valid", value, NULL);
}

/**
 * udisks_job_get_bytes: (skip)
 * @object: A #UDisksJob.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Bytes">"Bytes"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_job_get_bytes (UDisksJob *object)
{
  g_return_val_if_fail (UDISKS_IS_JOB (object), 0);

  return UDISKS_JOB_GET_IFACE (object)->get_bytes (object);
}

/**
 * udisks_job_set_bytes: (skip)
 * @object: A #UDisksJob.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Bytes">"Bytes"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_job_set_bytes (UDisksJob *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "bytes", value, NULL);
}

/**
 * udisks_job_get_rate: (skip)
 * @object: A #UDisksJob.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Rate">"Rate"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_job_get_rate (UDisksJob *object)
{
  g_return_val_if_fail (UDISKS_IS_JOB (object), 0);

  return UDISKS_JOB_GET_IFACE (object)->get_rate (object);
}

/**
 * udisks_job_set_rate: (skip)
 * @object: A #UDisksJob.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Rate">"Rate"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_job_set_rate (UDisksJob *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "rate", value, NULL);
}

/**
 * udisks_job_get_start_time: (skip)
 * @object: A #UDisksJob.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.StartTime">"StartTime"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_job_get_start_time (UDisksJob *object)
{
  g_return_val_if_fail (UDISKS_IS_JOB (object), 0);

  return UDISKS_JOB_GET_IFACE (object)->get_start_time (object);
}

/**
 * udisks_job_set_start_time: (skip)
 * @object: A #UDisksJob.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.StartTime">"StartTime"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_job_set_start_time (UDisksJob *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "start-time", value, NULL);
}

/**
 * udisks_job_get_expected_end_time: (skip)
 * @object: A #UDisksJob.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.ExpectedEndTime">"ExpectedEndTime"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint64 
udisks_job_get_expected_end_time (UDisksJob *object)
{
  g_return_val_if_fail (UDISKS_IS_JOB (object), 0);

  return UDISKS_JOB_GET_IFACE (object)->get_expected_end_time (object);
}

/**
 * udisks_job_set_expected_end_time: (skip)
 * @object: A #UDisksJob.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.ExpectedEndTime">"ExpectedEndTime"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_job_set_expected_end_time (UDisksJob *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "expected-end-time", value, NULL);
}

/**
 * udisks_job_get_objects: (skip)
 * @object: A #UDisksJob.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Objects">"Objects"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_job_dup_objects() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 */
const gchar *const *
udisks_job_get_objects (UDisksJob *object)
{
  g_return_val_if_fail (UDISKS_IS_JOB (object), NULL);

  return UDISKS_JOB_GET_IFACE (object)->get_objects (object);
}

/**
 * udisks_job_dup_objects: (skip)
 * @object: A #UDisksJob.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Objects">"Objects"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_strfreev().
 */
gchar **
udisks_job_dup_objects (UDisksJob *object)
{
  gchar **value;
  g_object_get (G_OBJECT (object), "objects", &value, NULL);
  return value;
}

/**
 * udisks_job_set_objects: (skip)
 * @object: A #UDisksJob.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Objects">"Objects"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_job_set_objects (UDisksJob *object, const gchar *const *value)
{
  g_object_set (G_OBJECT (object), "objects", value, NULL);
}

/**
 * udisks_job_get_started_by_uid: (skip)
 * @object: A #UDisksJob.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.StartedByUID">"StartedByUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
guint 
udisks_job_get_started_by_uid (UDisksJob *object)
{
  g_return_val_if_fail (UDISKS_IS_JOB (object), 0);

  return UDISKS_JOB_GET_IFACE (object)->get_started_by_uid (object);
}

/**
 * udisks_job_set_started_by_uid: (skip)
 * @object: A #UDisksJob.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.StartedByUID">"StartedByUID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_job_set_started_by_uid (UDisksJob *object, guint value)
{
  g_object_set (G_OBJECT (object), "started-by-uid", value, NULL);
}

/**
 * udisks_job_get_cancelable: (skip)
 * @object: A #UDisksJob.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Cancelable">"Cancelable"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 */
gboolean 
udisks_job_get_cancelable (UDisksJob *object)
{
  g_return_val_if_fail (UDISKS_IS_JOB (object), FALSE);

  return UDISKS_JOB_GET_IFACE (object)->get_cancelable (object);
}

/**
 * udisks_job_set_cancelable: (skip)
 * @object: A #UDisksJob.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Job.Cancelable">"Cancelable"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 */
void
udisks_job_set_cancelable (UDisksJob *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "cancelable", value, NULL);
}

/**
 * udisks_job_emit_completed:
 * @object: A #UDisksJob.
 * @arg_success: Argument to pass with the signal.
 * @arg_message: Argument to pass with the signal.
 *
 * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks2-Job.Completed">"Completed"</link> D-Bus signal.
 */
void
udisks_job_emit_completed (
    UDisksJob *object,
    gboolean arg_success,
    const gchar *arg_message)
{
  g_signal_emit (object, UDISKS__JOB_SIGNALS[UDISKS__JOB_COMPLETED], 0, arg_success, arg_message);
}

/**
 * udisks_job_call_cancel:
 * @proxy: A #UDisksJobProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Job.Cancel">Cancel()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_job_call_cancel_finish() to get the result of the operation.
 *
 * See udisks_job_call_cancel_sync() for the synchronous, blocking version of this method.
 */
void
udisks_job_call_cancel (
    UDisksJob *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Cancel",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_job_call_cancel_finish:
 * @proxy: A #UDisksJobProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_job_call_cancel().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_job_call_cancel().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_job_call_cancel_finish (
    UDisksJob *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_job_call_cancel_sync:
 * @proxy: A #UDisksJobProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Job.Cancel">Cancel()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_job_call_cancel() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 */
gboolean
udisks_job_call_cancel_sync (
    UDisksJob *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Cancel",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_job_complete_cancel:
 * @object: A #UDisksJob.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Job.Cancel">Cancel()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 */
void
udisks_job_complete_cancel (
    UDisksJob *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksJobProxy:
 *
 * The #UDisksJobProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksJobProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksJobProxy.
 */

struct _UDisksJobProxyPrivate
{
  GData *qdata;
};

static void udisks_job_proxy_iface_init (UDisksJobIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksJobProxy, udisks_job_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksJobProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_JOB, udisks_job_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksJobProxy, udisks_job_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_JOB, udisks_job_proxy_iface_init))

#endif
static void
udisks_job_proxy_finalize (GObject *object)
{
  UDisksJobProxy *proxy = UDISKS_JOB_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_job_proxy_parent_class)->finalize (object);
}

static void
udisks_job_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 10);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_job_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_job_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.Job: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_job_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 10);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_job_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.Job", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_job_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_job_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_job_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_JOB);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_JOB);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_job_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksJobProxy *proxy = UDISKS_JOB_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_job_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_job_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_job_proxy_get_operation (UDisksJob *object)
{
  UDisksJobProxy *proxy = UDISKS_JOB_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Operation");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static gdouble 
udisks_job_proxy_get_progress (UDisksJob *object)
{
  UDisksJobProxy *proxy = UDISKS_JOB_PROXY (object);
  GVariant *variant;
  gdouble value = 0.0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Progress");
  if (variant != NULL)
    {
      value = g_variant_get_double (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_job_proxy_get_progress_valid (UDisksJob *object)
{
  UDisksJobProxy *proxy = UDISKS_JOB_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ProgressValid");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_job_proxy_get_bytes (UDisksJob *object)
{
  UDisksJobProxy *proxy = UDISKS_JOB_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Bytes");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_job_proxy_get_rate (UDisksJob *object)
{
  UDisksJobProxy *proxy = UDISKS_JOB_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Rate");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_job_proxy_get_start_time (UDisksJob *object)
{
  UDisksJobProxy *proxy = UDISKS_JOB_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "StartTime");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_job_proxy_get_expected_end_time (UDisksJob *object)
{
  UDisksJobProxy *proxy = UDISKS_JOB_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ExpectedEndTime");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *const *
udisks_job_proxy_get_objects (UDisksJob *object)
{
  UDisksJobProxy *proxy = UDISKS_JOB_PROXY (object);
  GVariant *variant;
  const gchar *const *value = NULL;
  value = g_datalist_get_data (&proxy->priv->qdata, "Objects");
  if (value != NULL)
    return value;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Objects");
  if (variant != NULL)
    {
      value = g_variant_get_objv (variant, NULL);
      g_datalist_set_data_full (&proxy->priv->qdata, "Objects", (gpointer) value, g_free);
      g_variant_unref (variant);
    }
  return value;
}

static guint 
udisks_job_proxy_get_started_by_uid (UDisksJob *object)
{
  UDisksJobProxy *proxy = UDISKS_JOB_PROXY (object);
  GVariant *variant;
  guint value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "StartedByUID");
  if (variant != NULL)
    {
      value = g_variant_get_uint32 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_job_proxy_get_cancelable (UDisksJob *object)
{
  UDisksJobProxy *proxy = UDISKS_JOB_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Cancelable");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_job_proxy_init (UDisksJobProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_job_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_JOB_PROXY, UDisksJobProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_job_interface_info ());
}

static void
udisks_job_proxy_class_init (UDisksJobProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_job_proxy_finalize;
  gobject_class->get_property = udisks_job_proxy_get_property;
  gobject_class->set_property = udisks_job_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_job_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_job_proxy_g_properties_changed;

  udisks_job_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksJobProxyPrivate));
#endif
}

static void
udisks_job_proxy_iface_init (UDisksJobIface *iface)
{
  iface->get_operation = udisks_job_proxy_get_operation;
  iface->get_progress = udisks_job_proxy_get_progress;
  iface->get_progress_valid = udisks_job_proxy_get_progress_valid;
  iface->get_bytes = udisks_job_proxy_get_bytes;
  iface->get_rate = udisks_job_proxy_get_rate;
  iface->get_start_time = udisks_job_proxy_get_start_time;
  iface->get_expected_end_time = udisks_job_proxy_get_expected_end_time;
  iface->get_objects = udisks_job_proxy_get_objects;
  iface->get_started_by_uid = udisks_job_proxy_get_started_by_uid;
  iface->get_cancelable = udisks_job_proxy_get_cancelable;
}

/**
 * udisks_job_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Job.top_of_page">org.freedesktop.UDisks2.Job</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_job_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_job_proxy_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_job_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_JOB_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Job", NULL);
}

/**
 * udisks_job_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_job_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_job_proxy_new().
 *
 * Returns: (transfer full) (type UDisksJobProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksJob *
udisks_job_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_JOB (ret);
  else
    return NULL;
}

/**
 * udisks_job_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Job.top_of_page">org.freedesktop.UDisks2.Job</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_job_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksJobProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksJob *
udisks_job_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_JOB_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Job", NULL);
  if (ret != NULL)
    return UDISKS_JOB (ret);
  else
    return NULL;
}


/**
 * udisks_job_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_job_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_job_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_job_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_job_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_JOB_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Job", NULL);
}

/**
 * udisks_job_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_job_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_job_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksJobProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksJob *
udisks_job_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_JOB (ret);
  else
    return NULL;
}

/**
 * udisks_job_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_job_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_job_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksJobProxy): The constructed proxy object or %NULL if @error is set.
 */
UDisksJob *
udisks_job_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_JOB_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Job", NULL);
  if (ret != NULL)
    return UDISKS_JOB (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksJobSkeleton:
 *
 * The #UDisksJobSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksJobSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksJobSkeleton.
 */

struct _UDisksJobSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_job_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_JOB);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_JOB);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_job_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_job_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_job_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_job_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_job_skeleton_vtable =
{
  _udisks_job_skeleton_handle_method_call,
  _udisks_job_skeleton_handle_get_property,
  _udisks_job_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_job_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_job_interface_info ();
}

static GDBusInterfaceVTable *
udisks_job_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_job_skeleton_vtable;
}

static GVariant *
udisks_job_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_job_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_job_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_job_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_job_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Job", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_job_emit_changed (gpointer user_data);

static void
udisks_job_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_job_emit_changed (skeleton);
}

static void
_udisks_job_on_signal_completed (
    UDisksJob *object,
    gboolean arg_success,
    const gchar *arg_message)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);

  GList      *connections, *l;
  GVariant   *signal_variant;
  connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));

  signal_variant = g_variant_ref_sink (g_variant_new ("(bs)",
                   arg_success,
                   arg_message));
  for (l = connections; l != NULL; l = l->next)
    {
      GDBusConnection *connection = l->data;
      g_dbus_connection_emit_signal (connection,
        NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Job", "Completed",
        signal_variant, NULL);
    }
  g_variant_unref (signal_variant);
  g_list_free_full (connections, g_object_unref);
}

static void udisks_job_skeleton_iface_init (UDisksJobIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksJobSkeleton, udisks_job_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksJobSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_JOB, udisks_job_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksJobSkeleton, udisks_job_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_JOB, udisks_job_skeleton_iface_init))

#endif
static void
udisks_job_skeleton_finalize (GObject *object)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  guint n;
  for (n = 0; n < 10; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_job_skeleton_parent_class)->finalize (object);
}

static void
udisks_job_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 10);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_job_emit_changed (gpointer user_data)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.Job",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_job_schedule_emit_changed (UDisksJobSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_job_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_job_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_job_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_job_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 10);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_job_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_job_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_job_skeleton_init (UDisksJobSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_job_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_JOB_SKELETON, UDisksJobSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 10);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_DOUBLE);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[4], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[5], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[6], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[7], G_TYPE_STRV);
  g_value_init (&skeleton->priv->properties[8], G_TYPE_UINT);
  g_value_init (&skeleton->priv->properties[9], G_TYPE_BOOLEAN);
}

static const gchar *
udisks_job_skeleton_get_operation (UDisksJob *object)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gdouble 
udisks_job_skeleton_get_progress (UDisksJob *object)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  gdouble value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_double (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_job_skeleton_get_progress_valid (UDisksJob *object)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_job_skeleton_get_bytes (UDisksJob *object)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_job_skeleton_get_rate (UDisksJob *object)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[4]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_job_skeleton_get_start_time (UDisksJob *object)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[5]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_job_skeleton_get_expected_end_time (UDisksJob *object)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[6]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *const *
udisks_job_skeleton_get_objects (UDisksJob *object)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  const gchar *const *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boxed (&(skeleton->priv->properties[7]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint 
udisks_job_skeleton_get_started_by_uid (UDisksJob *object)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  guint value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint (&(skeleton->priv->properties[8]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_job_skeleton_get_cancelable (UDisksJob *object)
{
  UDisksJobSkeleton *skeleton = UDISKS_JOB_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[9]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_job_skeleton_class_init (UDisksJobSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_job_skeleton_finalize;
  gobject_class->get_property = udisks_job_skeleton_get_property;
  gobject_class->set_property = udisks_job_skeleton_set_property;
  gobject_class->notify       = udisks_job_skeleton_notify;


  udisks_job_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_job_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_job_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_job_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_job_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksJobSkeletonPrivate));
#endif
}

static void
udisks_job_skeleton_iface_init (UDisksJobIface *iface)
{
  iface->completed = _udisks_job_on_signal_completed;
  iface->get_operation = udisks_job_skeleton_get_operation;
  iface->get_progress = udisks_job_skeleton_get_progress;
  iface->get_progress_valid = udisks_job_skeleton_get_progress_valid;
  iface->get_bytes = udisks_job_skeleton_get_bytes;
  iface->get_rate = udisks_job_skeleton_get_rate;
  iface->get_start_time = udisks_job_skeleton_get_start_time;
  iface->get_expected_end_time = udisks_job_skeleton_get_expected_end_time;
  iface->get_objects = udisks_job_skeleton_get_objects;
  iface->get_started_by_uid = udisks_job_skeleton_get_started_by_uid;
  iface->get_cancelable = udisks_job_skeleton_get_cancelable;
}

/**
 * udisks_job_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Job.top_of_page">org.freedesktop.UDisks2.Job</link>.
 *
 * Returns: (transfer full) (type UDisksJobSkeleton): The skeleton object.
 */
UDisksJob *
udisks_job_skeleton_new (void)
{
  return UDISKS_JOB (g_object_new (UDISKS_TYPE_JOB_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Manager.BTRFS
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksManagerBTRFS
 * @title: UDisksManagerBTRFS
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Manager.BTRFS D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-BTRFS.top_of_page">org.freedesktop.UDisks2.Manager.BTRFS</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Manager.BTRFS ---- */

static const _ExtendedGDBusArgInfo _udisks_manager_btrfs_method_info_create_volume_IN_ARG_devices =
{
  {
    -1,
    (gchar *) "devices",
    (gchar *) "ao",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_btrfs_method_info_create_volume_IN_ARG_label =
{
  {
    -1,
    (gchar *) "label",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_btrfs_method_info_create_volume_IN_ARG_data_level =
{
  {
    -1,
    (gchar *) "data_level",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_btrfs_method_info_create_volume_IN_ARG_md_level =
{
  {
    -1,
    (gchar *) "md_level",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_btrfs_method_info_create_volume_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_btrfs_method_info_create_volume_IN_ARG_pointers[] =
{
  &_udisks_manager_btrfs_method_info_create_volume_IN_ARG_devices.parent_struct,
  &_udisks_manager_btrfs_method_info_create_volume_IN_ARG_label.parent_struct,
  &_udisks_manager_btrfs_method_info_create_volume_IN_ARG_data_level.parent_struct,
  &_udisks_manager_btrfs_method_info_create_volume_IN_ARG_md_level.parent_struct,
  &_udisks_manager_btrfs_method_info_create_volume_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_btrfs_method_info_create_volume =
{
  {
    -1,
    (gchar *) "CreateVolume",
    (GDBusArgInfo **) &_udisks_manager_btrfs_method_info_create_volume_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-create-volume",
  FALSE
};

static const GDBusMethodInfo * const _udisks_manager_btrfs_method_info_pointers[] =
{
  &_udisks_manager_btrfs_method_info_create_volume.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_manager_btrfs_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Manager.BTRFS",
    (GDBusMethodInfo **) &_udisks_manager_btrfs_method_info_pointers,
    NULL,
    NULL,
    NULL
  },
  "manager-btrfs",
};


/**
 * udisks_manager_btrfs_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-BTRFS.top_of_page">org.freedesktop.UDisks2.Manager.BTRFS</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 *
 * Since: 2.1.3
 */
GDBusInterfaceInfo *
udisks_manager_btrfs_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_manager_btrfs_interface_info.parent_struct;
}

/**
 * udisks_manager_btrfs_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksManagerBTRFS interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 *
 * Since: 2.1.3
 */
guint
udisks_manager_btrfs_override_properties (GObjectClass *klass G_GNUC_UNUSED, guint property_id_begin)
{
  return property_id_begin - 1;
}


inline static void
udisks_manager_btrfs_method_marshal_create_volume (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOXED_STRING_STRING_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksManagerBTRFS:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-BTRFS.top_of_page">org.freedesktop.UDisks2.Manager.BTRFS</link>.
 *
 * Since: 2.1.3
 */

/**
 * UDisksManagerBTRFSIface:
 * @parent_iface: The parent interface.
 * @handle_create_volume: Handler for the #UDisksManagerBTRFS::handle-create-volume signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-BTRFS.top_of_page">org.freedesktop.UDisks2.Manager.BTRFS</link>.
 *
 * Since: 2.1.3
 */

typedef UDisksManagerBTRFSIface UDisksManagerBTRFSInterface;
G_DEFINE_INTERFACE (UDisksManagerBTRFS, udisks_manager_btrfs, G_TYPE_OBJECT)

static void
udisks_manager_btrfs_default_init (UDisksManagerBTRFSIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksManagerBTRFS::handle-create-volume:
   * @object: A #UDisksManagerBTRFS.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_devices: Argument passed by remote caller.
   * @arg_label: Argument passed by remote caller.
   * @arg_data_level: Argument passed by remote caller.
   * @arg_md_level: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-BTRFS.CreateVolume">CreateVolume()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_btrfs_complete_create_volume() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.3.0
   */
  g_signal_new ("handle-create-volume",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerBTRFSIface, handle_create_volume),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_btrfs_method_marshal_create_volume,
    G_TYPE_BOOLEAN,
    6,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRV, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_VARIANT);

}

/**
 * udisks_manager_btrfs_call_create_volume:
 * @proxy: A #UDisksManagerBTRFSProxy.
 * @arg_devices: Argument to pass with the method invocation.
 * @arg_label: Argument to pass with the method invocation.
 * @arg_data_level: Argument to pass with the method invocation.
 * @arg_md_level: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-BTRFS.CreateVolume">CreateVolume()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_btrfs_call_create_volume_finish() to get the result of the operation.
 *
 * See udisks_manager_btrfs_call_create_volume_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.3.0
 */
void
udisks_manager_btrfs_call_create_volume (
    UDisksManagerBTRFS *proxy,
    const gchar *const *arg_devices,
    const gchar *arg_label,
    const gchar *arg_data_level,
    const gchar *arg_md_level,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CreateVolume",
    g_variant_new ("(^aosss@a{sv})",
                   arg_devices,
                   arg_label,
                   arg_data_level,
                   arg_md_level,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_btrfs_call_create_volume_finish:
 * @proxy: A #UDisksManagerBTRFSProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_btrfs_call_create_volume().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_btrfs_call_create_volume().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.3.0
 */
gboolean
udisks_manager_btrfs_call_create_volume_finish (
    UDisksManagerBTRFS *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_btrfs_call_create_volume_sync:
 * @proxy: A #UDisksManagerBTRFSProxy.
 * @arg_devices: Argument to pass with the method invocation.
 * @arg_label: Argument to pass with the method invocation.
 * @arg_data_level: Argument to pass with the method invocation.
 * @arg_md_level: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-BTRFS.CreateVolume">CreateVolume()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_btrfs_call_create_volume() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.3.0
 */
gboolean
udisks_manager_btrfs_call_create_volume_sync (
    UDisksManagerBTRFS *proxy,
    const gchar *const *arg_devices,
    const gchar *arg_label,
    const gchar *arg_data_level,
    const gchar *arg_md_level,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CreateVolume",
    g_variant_new ("(^aosss@a{sv})",
                   arg_devices,
                   arg_label,
                   arg_data_level,
                   arg_md_level,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_btrfs_complete_create_volume:
 * @object: A #UDisksManagerBTRFS.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-BTRFS.CreateVolume">CreateVolume()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.3.0
 */
void
udisks_manager_btrfs_complete_create_volume (
    UDisksManagerBTRFS *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksManagerBTRFSProxy:
 *
 * The #UDisksManagerBTRFSProxy structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.1.3
 */

/**
 * UDisksManagerBTRFSProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksManagerBTRFSProxy.
 *
 * Since: 2.1.3
 */

struct _UDisksManagerBTRFSProxyPrivate
{
  GData *qdata;
};

static void udisks_manager_btrfs_proxy_iface_init (UDisksManagerBTRFSIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksManagerBTRFSProxy, udisks_manager_btrfs_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksManagerBTRFSProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER_BTRFS, udisks_manager_btrfs_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksManagerBTRFSProxy, udisks_manager_btrfs_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER_BTRFS, udisks_manager_btrfs_proxy_iface_init))

#endif
static void
udisks_manager_btrfs_proxy_finalize (GObject *object)
{
  UDisksManagerBTRFSProxy *proxy = UDISKS_MANAGER_BTRFS_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_manager_btrfs_proxy_parent_class)->finalize (object);
}

static void
udisks_manager_btrfs_proxy_get_property (GObject      *object G_GNUC_UNUSED,
  guint         prop_id G_GNUC_UNUSED,
  GValue       *value G_GNUC_UNUSED,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
}

static void
udisks_manager_btrfs_proxy_set_property (GObject      *object G_GNUC_UNUSED,
  guint         prop_id G_GNUC_UNUSED,
  const GValue *value G_GNUC_UNUSED,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
}

static void
udisks_manager_btrfs_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_manager_btrfs_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_MANAGER_BTRFS);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_MANAGER_BTRFS);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_manager_btrfs_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksManagerBTRFSProxy *proxy = UDISKS_MANAGER_BTRFS_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_btrfs_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_btrfs_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static void
udisks_manager_btrfs_proxy_init (UDisksManagerBTRFSProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_manager_btrfs_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_MANAGER_BTRFS_PROXY, UDisksManagerBTRFSProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_manager_btrfs_interface_info ());
}

static void
udisks_manager_btrfs_proxy_class_init (UDisksManagerBTRFSProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_manager_btrfs_proxy_finalize;
  gobject_class->get_property = udisks_manager_btrfs_proxy_get_property;
  gobject_class->set_property = udisks_manager_btrfs_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_manager_btrfs_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_manager_btrfs_proxy_g_properties_changed;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksManagerBTRFSProxyPrivate));
#endif
}

static void
udisks_manager_btrfs_proxy_iface_init (UDisksManagerBTRFSIface *iface G_GNUC_UNUSED)
{
}

/**
 * udisks_manager_btrfs_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-BTRFS.top_of_page">org.freedesktop.UDisks2.Manager.BTRFS</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_btrfs_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_manager_btrfs_proxy_new_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.1.3
 */
void
udisks_manager_btrfs_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_MANAGER_BTRFS_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager.BTRFS", NULL);
}

/**
 * udisks_manager_btrfs_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_btrfs_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_manager_btrfs_proxy_new().
 *
 * Returns: (transfer full) (type UDisksManagerBTRFSProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.1.3
 */
UDisksManagerBTRFS *
udisks_manager_btrfs_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_MANAGER_BTRFS (ret);
  else
    return NULL;
}

/**
 * udisks_manager_btrfs_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-BTRFS.top_of_page">org.freedesktop.UDisks2.Manager.BTRFS</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_btrfs_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksManagerBTRFSProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.1.3
 */
UDisksManagerBTRFS *
udisks_manager_btrfs_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_MANAGER_BTRFS_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager.BTRFS", NULL);
  if (ret != NULL)
    return UDISKS_MANAGER_BTRFS (ret);
  else
    return NULL;
}


/**
 * udisks_manager_btrfs_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_manager_btrfs_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_btrfs_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_manager_btrfs_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.1.3
 */
void
udisks_manager_btrfs_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_MANAGER_BTRFS_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager.BTRFS", NULL);
}

/**
 * udisks_manager_btrfs_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_btrfs_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_manager_btrfs_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksManagerBTRFSProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.1.3
 */
UDisksManagerBTRFS *
udisks_manager_btrfs_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_MANAGER_BTRFS (ret);
  else
    return NULL;
}

/**
 * udisks_manager_btrfs_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_manager_btrfs_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_btrfs_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksManagerBTRFSProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.1.3
 */
UDisksManagerBTRFS *
udisks_manager_btrfs_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_MANAGER_BTRFS_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager.BTRFS", NULL);
  if (ret != NULL)
    return UDISKS_MANAGER_BTRFS (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksManagerBTRFSSkeleton:
 *
 * The #UDisksManagerBTRFSSkeleton structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.1.3
 */

/**
 * UDisksManagerBTRFSSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksManagerBTRFSSkeleton.
 *
 * Since: 2.1.3
 */

struct _UDisksManagerBTRFSSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_manager_btrfs_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksManagerBTRFSSkeleton *skeleton = UDISKS_MANAGER_BTRFS_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_MANAGER_BTRFS);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_MANAGER_BTRFS);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_manager_btrfs_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksManagerBTRFSSkeleton *skeleton = UDISKS_MANAGER_BTRFS_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_btrfs_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_manager_btrfs_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksManagerBTRFSSkeleton *skeleton = UDISKS_MANAGER_BTRFS_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_btrfs_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_manager_btrfs_skeleton_vtable =
{
  _udisks_manager_btrfs_skeleton_handle_method_call,
  _udisks_manager_btrfs_skeleton_handle_get_property,
  _udisks_manager_btrfs_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_manager_btrfs_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_manager_btrfs_interface_info ();
}

static GDBusInterfaceVTable *
udisks_manager_btrfs_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_manager_btrfs_skeleton_vtable;
}

static GVariant *
udisks_manager_btrfs_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksManagerBTRFSSkeleton *skeleton = UDISKS_MANAGER_BTRFS_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_manager_btrfs_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_manager_btrfs_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_manager_btrfs_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_manager_btrfs_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Manager.BTRFS", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static void
udisks_manager_btrfs_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton G_GNUC_UNUSED)
{
}

static void udisks_manager_btrfs_skeleton_iface_init (UDisksManagerBTRFSIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksManagerBTRFSSkeleton, udisks_manager_btrfs_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksManagerBTRFSSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER_BTRFS, udisks_manager_btrfs_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksManagerBTRFSSkeleton, udisks_manager_btrfs_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER_BTRFS, udisks_manager_btrfs_skeleton_iface_init))

#endif
static void
udisks_manager_btrfs_skeleton_finalize (GObject *object)
{
  UDisksManagerBTRFSSkeleton *skeleton = UDISKS_MANAGER_BTRFS_SKELETON (object);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_manager_btrfs_skeleton_parent_class)->finalize (object);
}

static void
udisks_manager_btrfs_skeleton_init (UDisksManagerBTRFSSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_manager_btrfs_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_MANAGER_BTRFS_SKELETON, UDisksManagerBTRFSSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
}

static void
udisks_manager_btrfs_skeleton_class_init (UDisksManagerBTRFSSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_manager_btrfs_skeleton_finalize;

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_manager_btrfs_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_manager_btrfs_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_manager_btrfs_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_manager_btrfs_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksManagerBTRFSSkeletonPrivate));
#endif
}

static void
udisks_manager_btrfs_skeleton_iface_init (UDisksManagerBTRFSIface *iface G_GNUC_UNUSED)
{
}

/**
 * udisks_manager_btrfs_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-BTRFS.top_of_page">org.freedesktop.UDisks2.Manager.BTRFS</link>.
 *
 * Returns: (transfer full) (type UDisksManagerBTRFSSkeleton): The skeleton object.
 *
 * Since: 2.1.3
 */
UDisksManagerBTRFS *
udisks_manager_btrfs_skeleton_new (void)
{
  return UDISKS_MANAGER_BTRFS (g_object_new (UDISKS_TYPE_MANAGER_BTRFS_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Filesystem.BTRFS
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksFilesystemBTRFS
 * @title: UDisksFilesystemBTRFS
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Filesystem.BTRFS D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem-BTRFS.top_of_page">org.freedesktop.UDisks2.Filesystem.BTRFS</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Filesystem.BTRFS ---- */

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_add_device_IN_ARG_device =
{
  {
    -1,
    (gchar *) "device",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_add_device_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_btrfs_method_info_add_device_IN_ARG_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_add_device_IN_ARG_device.parent_struct,
  &_udisks_filesystem_btrfs_method_info_add_device_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_btrfs_method_info_add_device =
{
  {
    -1,
    (gchar *) "AddDevice",
    (GDBusArgInfo **) &_udisks_filesystem_btrfs_method_info_add_device_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-add-device",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_remove_device_IN_ARG_device =
{
  {
    -1,
    (gchar *) "device",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_remove_device_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_btrfs_method_info_remove_device_IN_ARG_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_remove_device_IN_ARG_device.parent_struct,
  &_udisks_filesystem_btrfs_method_info_remove_device_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_btrfs_method_info_remove_device =
{
  {
    -1,
    (gchar *) "RemoveDevice",
    (GDBusArgInfo **) &_udisks_filesystem_btrfs_method_info_remove_device_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-remove-device",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_create_subvolume_IN_ARG_name =
{
  {
    -1,
    (gchar *) "name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_create_subvolume_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_btrfs_method_info_create_subvolume_IN_ARG_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_create_subvolume_IN_ARG_name.parent_struct,
  &_udisks_filesystem_btrfs_method_info_create_subvolume_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_btrfs_method_info_create_subvolume =
{
  {
    -1,
    (gchar *) "CreateSubvolume",
    (GDBusArgInfo **) &_udisks_filesystem_btrfs_method_info_create_subvolume_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-create-subvolume",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_remove_subvolume_IN_ARG_name =
{
  {
    -1,
    (gchar *) "name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_remove_subvolume_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_btrfs_method_info_remove_subvolume_IN_ARG_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_remove_subvolume_IN_ARG_name.parent_struct,
  &_udisks_filesystem_btrfs_method_info_remove_subvolume_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_btrfs_method_info_remove_subvolume =
{
  {
    -1,
    (gchar *) "RemoveSubvolume",
    (GDBusArgInfo **) &_udisks_filesystem_btrfs_method_info_remove_subvolume_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-remove-subvolume",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_get_subvolumes_IN_ARG_snapshots_only =
{
  {
    -1,
    (gchar *) "snapshots_only",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_get_subvolumes_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_btrfs_method_info_get_subvolumes_IN_ARG_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_get_subvolumes_IN_ARG_snapshots_only.parent_struct,
  &_udisks_filesystem_btrfs_method_info_get_subvolumes_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_get_subvolumes_OUT_ARG_subvolumes =
{
  {
    -1,
    (gchar *) "subvolumes",
    (gchar *) "a(tts)",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_get_subvolumes_OUT_ARG_subvolumes_cnt =
{
  {
    -1,
    (gchar *) "subvolumes_cnt",
    (gchar *) "i",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_btrfs_method_info_get_subvolumes_OUT_ARG_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_get_subvolumes_OUT_ARG_subvolumes.parent_struct,
  &_udisks_filesystem_btrfs_method_info_get_subvolumes_OUT_ARG_subvolumes_cnt.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_btrfs_method_info_get_subvolumes =
{
  {
    -1,
    (gchar *) "GetSubvolumes",
    (GDBusArgInfo **) &_udisks_filesystem_btrfs_method_info_get_subvolumes_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_filesystem_btrfs_method_info_get_subvolumes_OUT_ARG_pointers,
    NULL
  },
  "handle-get-subvolumes",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_create_snapshot_IN_ARG_source =
{
  {
    -1,
    (gchar *) "source",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_create_snapshot_IN_ARG_dest =
{
  {
    -1,
    (gchar *) "dest",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_create_snapshot_IN_ARG_ro =
{
  {
    -1,
    (gchar *) "ro",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_create_snapshot_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_btrfs_method_info_create_snapshot_IN_ARG_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_create_snapshot_IN_ARG_source.parent_struct,
  &_udisks_filesystem_btrfs_method_info_create_snapshot_IN_ARG_dest.parent_struct,
  &_udisks_filesystem_btrfs_method_info_create_snapshot_IN_ARG_ro.parent_struct,
  &_udisks_filesystem_btrfs_method_info_create_snapshot_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_btrfs_method_info_create_snapshot =
{
  {
    -1,
    (gchar *) "CreateSnapshot",
    (GDBusArgInfo **) &_udisks_filesystem_btrfs_method_info_create_snapshot_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-create-snapshot",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_repair_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_btrfs_method_info_repair_IN_ARG_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_repair_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_btrfs_method_info_repair =
{
  {
    -1,
    (gchar *) "Repair",
    (GDBusArgInfo **) &_udisks_filesystem_btrfs_method_info_repair_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-repair",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_resize_IN_ARG_size =
{
  {
    -1,
    (gchar *) "size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_resize_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_btrfs_method_info_resize_IN_ARG_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_resize_IN_ARG_size.parent_struct,
  &_udisks_filesystem_btrfs_method_info_resize_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_btrfs_method_info_resize =
{
  {
    -1,
    (gchar *) "Resize",
    (GDBusArgInfo **) &_udisks_filesystem_btrfs_method_info_resize_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-resize",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_set_label_IN_ARG_label =
{
  {
    -1,
    (gchar *) "label",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_set_label_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_btrfs_method_info_set_label_IN_ARG_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_set_label_IN_ARG_label.parent_struct,
  &_udisks_filesystem_btrfs_method_info_set_label_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_btrfs_method_info_set_label =
{
  {
    -1,
    (gchar *) "SetLabel",
    (GDBusArgInfo **) &_udisks_filesystem_btrfs_method_info_set_label_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-label",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_get_default_subvolume_id_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_btrfs_method_info_get_default_subvolume_id_IN_ARG_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_get_default_subvolume_id_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_get_default_subvolume_id_OUT_ARG_id =
{
  {
    -1,
    (gchar *) "id",
    (gchar *) "u",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_btrfs_method_info_get_default_subvolume_id_OUT_ARG_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_get_default_subvolume_id_OUT_ARG_id.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_btrfs_method_info_get_default_subvolume_id =
{
  {
    -1,
    (gchar *) "GetDefaultSubvolumeID",
    (GDBusArgInfo **) &_udisks_filesystem_btrfs_method_info_get_default_subvolume_id_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_filesystem_btrfs_method_info_get_default_subvolume_id_OUT_ARG_pointers,
    NULL
  },
  "handle-get-default-subvolume-id",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_set_default_subvolume_id_IN_ARG_id =
{
  {
    -1,
    (gchar *) "id",
    (gchar *) "u",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_filesystem_btrfs_method_info_set_default_subvolume_id_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_filesystem_btrfs_method_info_set_default_subvolume_id_IN_ARG_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_set_default_subvolume_id_IN_ARG_id.parent_struct,
  &_udisks_filesystem_btrfs_method_info_set_default_subvolume_id_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_filesystem_btrfs_method_info_set_default_subvolume_id =
{
  {
    -1,
    (gchar *) "SetDefaultSubvolumeID",
    (GDBusArgInfo **) &_udisks_filesystem_btrfs_method_info_set_default_subvolume_id_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-set-default-subvolume-id",
  FALSE
};

static const GDBusMethodInfo * const _udisks_filesystem_btrfs_method_info_pointers[] =
{
  &_udisks_filesystem_btrfs_method_info_add_device.parent_struct,
  &_udisks_filesystem_btrfs_method_info_remove_device.parent_struct,
  &_udisks_filesystem_btrfs_method_info_create_subvolume.parent_struct,
  &_udisks_filesystem_btrfs_method_info_remove_subvolume.parent_struct,
  &_udisks_filesystem_btrfs_method_info_get_subvolumes.parent_struct,
  &_udisks_filesystem_btrfs_method_info_create_snapshot.parent_struct,
  &_udisks_filesystem_btrfs_method_info_repair.parent_struct,
  &_udisks_filesystem_btrfs_method_info_resize.parent_struct,
  &_udisks_filesystem_btrfs_method_info_set_label.parent_struct,
  &_udisks_filesystem_btrfs_method_info_get_default_subvolume_id.parent_struct,
  &_udisks_filesystem_btrfs_method_info_set_default_subvolume_id.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_filesystem_btrfs_property_info_label =
{
  {
    -1,
    (gchar *) "label",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "label",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_filesystem_btrfs_property_info_uuid =
{
  {
    -1,
    (gchar *) "uuid",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "uuid",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_filesystem_btrfs_property_info_num_devices =
{
  {
    -1,
    (gchar *) "num_devices",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "num-devices",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_filesystem_btrfs_property_info_used =
{
  {
    -1,
    (gchar *) "used",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "used",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_filesystem_btrfs_property_info_pointers[] =
{
  &_udisks_filesystem_btrfs_property_info_label.parent_struct,
  &_udisks_filesystem_btrfs_property_info_uuid.parent_struct,
  &_udisks_filesystem_btrfs_property_info_num_devices.parent_struct,
  &_udisks_filesystem_btrfs_property_info_used.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_filesystem_btrfs_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Filesystem.BTRFS",
    (GDBusMethodInfo **) &_udisks_filesystem_btrfs_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_filesystem_btrfs_property_info_pointers,
    NULL
  },
  "filesystem-btrfs",
};


/**
 * udisks_filesystem_btrfs_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem-BTRFS.top_of_page">org.freedesktop.UDisks2.Filesystem.BTRFS</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 *
 * Since: 2.1.3
 */
GDBusInterfaceInfo *
udisks_filesystem_btrfs_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_filesystem_btrfs_interface_info.parent_struct;
}

/**
 * udisks_filesystem_btrfs_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksFilesystemBTRFS interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 *
 * Since: 2.1.3
 */
guint
udisks_filesystem_btrfs_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "label");
  g_object_class_override_property (klass, property_id_begin++, "uuid");
  g_object_class_override_property (klass, property_id_begin++, "num-devices");
  g_object_class_override_property (klass, property_id_begin++, "used");
  return property_id_begin - 1;
}


inline static void
udisks_filesystem_btrfs_method_marshal_add_device (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_btrfs_method_marshal_remove_device (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_btrfs_method_marshal_create_subvolume (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_btrfs_method_marshal_remove_subvolume (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_btrfs_method_marshal_get_subvolumes (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOOLEAN_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_btrfs_method_marshal_create_snapshot (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_STRING_BOOLEAN_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_btrfs_method_marshal_repair (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_btrfs_method_marshal_resize (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT64_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_btrfs_method_marshal_set_label (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_btrfs_method_marshal_get_default_subvolume_id (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_filesystem_btrfs_method_marshal_set_default_subvolume_id (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksFilesystemBTRFS:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem-BTRFS.top_of_page">org.freedesktop.UDisks2.Filesystem.BTRFS</link>.
 *
 * Since: 2.1.3
 */

/**
 * UDisksFilesystemBTRFSIface:
 * @parent_iface: The parent interface.
 * @handle_create_snapshot: Handler for the #UDisksFilesystemBTRFS::handle-create-snapshot signal.
 * @handle_create_subvolume: Handler for the #UDisksFilesystemBTRFS::handle-create-subvolume signal.
 * @handle_get_subvolumes: Handler for the #UDisksFilesystemBTRFS::handle-get-subvolumes signal.
 * @handle_remove_subvolume: Handler for the #UDisksFilesystemBTRFS::handle-remove-subvolume signal.
 * @handle_set_label: Handler for the #UDisksFilesystemBTRFS::handle-set-label signal.
 * @get_label: Getter for the #UDisksFilesystemBTRFS:label property.
 * @get_num_devices: Getter for the #UDisksFilesystemBTRFS:num-devices property.
 * @get_used: Getter for the #UDisksFilesystemBTRFS:used property.
 * @get_uuid: Getter for the #UDisksFilesystemBTRFS:uuid property.
 * @handle_add_device: Handler for the #UDisksFilesystemBTRFS::handle-add-device signal.
 * @handle_remove_device: Handler for the #UDisksFilesystemBTRFS::handle-remove-device signal.
 * @handle_repair: Handler for the #UDisksFilesystemBTRFS::handle-repair signal.
 * @handle_resize: Handler for the #UDisksFilesystemBTRFS::handle-resize signal.
 * @handle_get_default_subvolume_id: Handler for the #UDisksFilesystemBTRFS::handle-get-default-subvolume-id signal.
 * @handle_set_default_subvolume_id: Handler for the #UDisksFilesystemBTRFS::handle-set-default-subvolume-id signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem-BTRFS.top_of_page">org.freedesktop.UDisks2.Filesystem.BTRFS</link>.
 *
 * Since: 2.1.3
 */

typedef UDisksFilesystemBTRFSIface UDisksFilesystemBTRFSInterface;
G_DEFINE_INTERFACE (UDisksFilesystemBTRFS, udisks_filesystem_btrfs, G_TYPE_OBJECT)

static void
udisks_filesystem_btrfs_default_init (UDisksFilesystemBTRFSIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksFilesystemBTRFS::handle-add-device:
   * @object: A #UDisksFilesystemBTRFS.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_device: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.AddDevice">AddDevice()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_btrfs_complete_add_device() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.3.0
   */
  g_signal_new ("handle-add-device",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemBTRFSIface, handle_add_device),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_btrfs_method_marshal_add_device,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksFilesystemBTRFS::handle-remove-device:
   * @object: A #UDisksFilesystemBTRFS.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_device: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.RemoveDevice">RemoveDevice()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_btrfs_complete_remove_device() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.3.0
   */
  g_signal_new ("handle-remove-device",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemBTRFSIface, handle_remove_device),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_btrfs_method_marshal_remove_device,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksFilesystemBTRFS::handle-create-subvolume:
   * @object: A #UDisksFilesystemBTRFS.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_name: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.CreateSubvolume">CreateSubvolume()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_btrfs_complete_create_subvolume() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.1.3
   */
  g_signal_new ("handle-create-subvolume",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemBTRFSIface, handle_create_subvolume),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_btrfs_method_marshal_create_subvolume,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksFilesystemBTRFS::handle-remove-subvolume:
   * @object: A #UDisksFilesystemBTRFS.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_name: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.RemoveSubvolume">RemoveSubvolume()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_btrfs_complete_remove_subvolume() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.1.3
   */
  g_signal_new ("handle-remove-subvolume",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemBTRFSIface, handle_remove_subvolume),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_btrfs_method_marshal_remove_subvolume,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksFilesystemBTRFS::handle-get-subvolumes:
   * @object: A #UDisksFilesystemBTRFS.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_snapshots_only: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.GetSubvolumes">GetSubvolumes()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_btrfs_complete_get_subvolumes() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.1.3
   */
  g_signal_new ("handle-get-subvolumes",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemBTRFSIface, handle_get_subvolumes),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_btrfs_method_marshal_get_subvolumes,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_BOOLEAN, G_TYPE_VARIANT);

  /**
   * UDisksFilesystemBTRFS::handle-create-snapshot:
   * @object: A #UDisksFilesystemBTRFS.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_source: Argument passed by remote caller.
   * @arg_dest: Argument passed by remote caller.
   * @arg_ro: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.CreateSnapshot">CreateSnapshot()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_btrfs_complete_create_snapshot() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.1.3
   */
  g_signal_new ("handle-create-snapshot",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemBTRFSIface, handle_create_snapshot),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_btrfs_method_marshal_create_snapshot,
    G_TYPE_BOOLEAN,
    5,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_VARIANT);

  /**
   * UDisksFilesystemBTRFS::handle-repair:
   * @object: A #UDisksFilesystemBTRFS.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.Repair">Repair()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_btrfs_complete_repair() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.3.0
   */
  g_signal_new ("handle-repair",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemBTRFSIface, handle_repair),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_btrfs_method_marshal_repair,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksFilesystemBTRFS::handle-resize:
   * @object: A #UDisksFilesystemBTRFS.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_size: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.Resize">Resize()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_btrfs_complete_resize() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.3.0
   */
  g_signal_new ("handle-resize",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemBTRFSIface, handle_resize),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_btrfs_method_marshal_resize,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT64, G_TYPE_VARIANT);

  /**
   * UDisksFilesystemBTRFS::handle-set-label:
   * @object: A #UDisksFilesystemBTRFS.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_label: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.SetLabel">SetLabel()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_btrfs_complete_set_label() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.1.3
   */
  g_signal_new ("handle-set-label",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemBTRFSIface, handle_set_label),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_btrfs_method_marshal_set_label,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksFilesystemBTRFS::handle-get-default-subvolume-id:
   * @object: A #UDisksFilesystemBTRFS.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.GetDefaultSubvolumeID">GetDefaultSubvolumeID()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_btrfs_complete_get_default_subvolume_id() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.11.0
   */
  g_signal_new ("handle-get-default-subvolume-id",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemBTRFSIface, handle_get_default_subvolume_id),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_btrfs_method_marshal_get_default_subvolume_id,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksFilesystemBTRFS::handle-set-default-subvolume-id:
   * @object: A #UDisksFilesystemBTRFS.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_id: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.SetDefaultSubvolumeID">SetDefaultSubvolumeID()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_filesystem_btrfs_complete_set_default_subvolume_id() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.11.0
   */
  g_signal_new ("handle-set-default-subvolume-id",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksFilesystemBTRFSIface, handle_set_default_subvolume_id),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_filesystem_btrfs_method_marshal_set_default_subvolume_id,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksFilesystemBTRFS:label:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.label">"label"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.1.3
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("label", "label", "label", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksFilesystemBTRFS:uuid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.uuid">"uuid"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.1.3
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("uuid", "uuid", "uuid", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksFilesystemBTRFS:num-devices:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.num_devices">"num_devices"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.1.3
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("num-devices", "num_devices", "num_devices", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksFilesystemBTRFS:used:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.used">"used"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.1.3
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("used", "used", "used", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_filesystem_btrfs_get_label: (skip)
 * @object: A #UDisksFilesystemBTRFS.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.label">"label"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_filesystem_btrfs_dup_label() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.1.3
 */
const gchar *
udisks_filesystem_btrfs_get_label (UDisksFilesystemBTRFS *object)
{
  g_return_val_if_fail (UDISKS_IS_FILESYSTEM_BTRFS (object), NULL);

  return UDISKS_FILESYSTEM_BTRFS_GET_IFACE (object)->get_label (object);
}

/**
 * udisks_filesystem_btrfs_dup_label: (skip)
 * @object: A #UDisksFilesystemBTRFS.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.label">"label"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.1.3
 */
gchar *
udisks_filesystem_btrfs_dup_label (UDisksFilesystemBTRFS *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "label", &value, NULL);
  return value;
}

/**
 * udisks_filesystem_btrfs_set_label: (skip)
 * @object: A #UDisksFilesystemBTRFS.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.label">"label"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_set_label (UDisksFilesystemBTRFS *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "label", value, NULL);
}

/**
 * udisks_filesystem_btrfs_get_uuid: (skip)
 * @object: A #UDisksFilesystemBTRFS.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.uuid">"uuid"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_filesystem_btrfs_dup_uuid() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.1.3
 */
const gchar *
udisks_filesystem_btrfs_get_uuid (UDisksFilesystemBTRFS *object)
{
  g_return_val_if_fail (UDISKS_IS_FILESYSTEM_BTRFS (object), NULL);

  return UDISKS_FILESYSTEM_BTRFS_GET_IFACE (object)->get_uuid (object);
}

/**
 * udisks_filesystem_btrfs_dup_uuid: (skip)
 * @object: A #UDisksFilesystemBTRFS.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.uuid">"uuid"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.1.3
 */
gchar *
udisks_filesystem_btrfs_dup_uuid (UDisksFilesystemBTRFS *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "uuid", &value, NULL);
  return value;
}

/**
 * udisks_filesystem_btrfs_set_uuid: (skip)
 * @object: A #UDisksFilesystemBTRFS.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.uuid">"uuid"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_set_uuid (UDisksFilesystemBTRFS *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "uuid", value, NULL);
}

/**
 * udisks_filesystem_btrfs_get_num_devices: (skip)
 * @object: A #UDisksFilesystemBTRFS.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.num_devices">"num_devices"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.1.3
 */
guint64 
udisks_filesystem_btrfs_get_num_devices (UDisksFilesystemBTRFS *object)
{
  g_return_val_if_fail (UDISKS_IS_FILESYSTEM_BTRFS (object), 0);

  return UDISKS_FILESYSTEM_BTRFS_GET_IFACE (object)->get_num_devices (object);
}

/**
 * udisks_filesystem_btrfs_set_num_devices: (skip)
 * @object: A #UDisksFilesystemBTRFS.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.num_devices">"num_devices"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_set_num_devices (UDisksFilesystemBTRFS *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "num-devices", value, NULL);
}

/**
 * udisks_filesystem_btrfs_get_used: (skip)
 * @object: A #UDisksFilesystemBTRFS.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.used">"used"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.1.3
 */
guint64 
udisks_filesystem_btrfs_get_used (UDisksFilesystemBTRFS *object)
{
  g_return_val_if_fail (UDISKS_IS_FILESYSTEM_BTRFS (object), 0);

  return UDISKS_FILESYSTEM_BTRFS_GET_IFACE (object)->get_used (object);
}

/**
 * udisks_filesystem_btrfs_set_used: (skip)
 * @object: A #UDisksFilesystemBTRFS.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Filesystem-BTRFS.used">"used"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_set_used (UDisksFilesystemBTRFS *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "used", value, NULL);
}

/**
 * udisks_filesystem_btrfs_call_add_device:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_device: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.AddDevice">AddDevice()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_btrfs_call_add_device_finish() to get the result of the operation.
 *
 * See udisks_filesystem_btrfs_call_add_device_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.3.0
 */
void
udisks_filesystem_btrfs_call_add_device (
    UDisksFilesystemBTRFS *proxy,
    const gchar *arg_device,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "AddDevice",
    g_variant_new ("(o@a{sv})",
                   arg_device,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_btrfs_call_add_device_finish:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_btrfs_call_add_device().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_btrfs_call_add_device().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.3.0
 */
gboolean
udisks_filesystem_btrfs_call_add_device_finish (
    UDisksFilesystemBTRFS *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_add_device_sync:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_device: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.AddDevice">AddDevice()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_btrfs_call_add_device() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.3.0
 */
gboolean
udisks_filesystem_btrfs_call_add_device_sync (
    UDisksFilesystemBTRFS *proxy,
    const gchar *arg_device,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "AddDevice",
    g_variant_new ("(o@a{sv})",
                   arg_device,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_remove_device:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_device: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.RemoveDevice">RemoveDevice()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_btrfs_call_remove_device_finish() to get the result of the operation.
 *
 * See udisks_filesystem_btrfs_call_remove_device_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.3.0
 */
void
udisks_filesystem_btrfs_call_remove_device (
    UDisksFilesystemBTRFS *proxy,
    const gchar *arg_device,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "RemoveDevice",
    g_variant_new ("(o@a{sv})",
                   arg_device,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_btrfs_call_remove_device_finish:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_btrfs_call_remove_device().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_btrfs_call_remove_device().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.3.0
 */
gboolean
udisks_filesystem_btrfs_call_remove_device_finish (
    UDisksFilesystemBTRFS *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_remove_device_sync:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_device: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.RemoveDevice">RemoveDevice()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_btrfs_call_remove_device() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.3.0
 */
gboolean
udisks_filesystem_btrfs_call_remove_device_sync (
    UDisksFilesystemBTRFS *proxy,
    const gchar *arg_device,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "RemoveDevice",
    g_variant_new ("(o@a{sv})",
                   arg_device,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_create_subvolume:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.CreateSubvolume">CreateSubvolume()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_btrfs_call_create_subvolume_finish() to get the result of the operation.
 *
 * See udisks_filesystem_btrfs_call_create_subvolume_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_call_create_subvolume (
    UDisksFilesystemBTRFS *proxy,
    const gchar *arg_name,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CreateSubvolume",
    g_variant_new ("(s@a{sv})",
                   arg_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_btrfs_call_create_subvolume_finish:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_btrfs_call_create_subvolume().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_btrfs_call_create_subvolume().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.1.3
 */
gboolean
udisks_filesystem_btrfs_call_create_subvolume_finish (
    UDisksFilesystemBTRFS *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_create_subvolume_sync:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.CreateSubvolume">CreateSubvolume()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_btrfs_call_create_subvolume() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.1.3
 */
gboolean
udisks_filesystem_btrfs_call_create_subvolume_sync (
    UDisksFilesystemBTRFS *proxy,
    const gchar *arg_name,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CreateSubvolume",
    g_variant_new ("(s@a{sv})",
                   arg_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_remove_subvolume:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.RemoveSubvolume">RemoveSubvolume()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_btrfs_call_remove_subvolume_finish() to get the result of the operation.
 *
 * See udisks_filesystem_btrfs_call_remove_subvolume_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_call_remove_subvolume (
    UDisksFilesystemBTRFS *proxy,
    const gchar *arg_name,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "RemoveSubvolume",
    g_variant_new ("(s@a{sv})",
                   arg_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_btrfs_call_remove_subvolume_finish:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_btrfs_call_remove_subvolume().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_btrfs_call_remove_subvolume().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.1.3
 */
gboolean
udisks_filesystem_btrfs_call_remove_subvolume_finish (
    UDisksFilesystemBTRFS *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_remove_subvolume_sync:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.RemoveSubvolume">RemoveSubvolume()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_btrfs_call_remove_subvolume() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.1.3
 */
gboolean
udisks_filesystem_btrfs_call_remove_subvolume_sync (
    UDisksFilesystemBTRFS *proxy,
    const gchar *arg_name,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "RemoveSubvolume",
    g_variant_new ("(s@a{sv})",
                   arg_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_get_subvolumes:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_snapshots_only: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.GetSubvolumes">GetSubvolumes()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_btrfs_call_get_subvolumes_finish() to get the result of the operation.
 *
 * See udisks_filesystem_btrfs_call_get_subvolumes_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_call_get_subvolumes (
    UDisksFilesystemBTRFS *proxy,
    gboolean arg_snapshots_only,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "GetSubvolumes",
    g_variant_new ("(b@a{sv})",
                   arg_snapshots_only,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_btrfs_call_get_subvolumes_finish:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @out_subvolumes: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @out_subvolumes_cnt: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_btrfs_call_get_subvolumes().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_btrfs_call_get_subvolumes().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.1.3
 */
gboolean
udisks_filesystem_btrfs_call_get_subvolumes_finish (
    UDisksFilesystemBTRFS *proxy,
    GVariant ** out_subvolumes,
    gint* out_subvolumes_cnt,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@a(tts)i)",
                 out_subvolumes,
                 out_subvolumes_cnt);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_get_subvolumes_sync:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_snapshots_only: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_subvolumes: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @out_subvolumes_cnt: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.GetSubvolumes">GetSubvolumes()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_btrfs_call_get_subvolumes() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.1.3
 */
gboolean
udisks_filesystem_btrfs_call_get_subvolumes_sync (
    UDisksFilesystemBTRFS *proxy,
    gboolean arg_snapshots_only,
    GVariant *arg_options,
    GVariant ** out_subvolumes,
    gint* out_subvolumes_cnt,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "GetSubvolumes",
    g_variant_new ("(b@a{sv})",
                   arg_snapshots_only,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@a(tts)i)",
                 out_subvolumes,
                 out_subvolumes_cnt);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_create_snapshot:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_source: Argument to pass with the method invocation.
 * @arg_dest: Argument to pass with the method invocation.
 * @arg_ro: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.CreateSnapshot">CreateSnapshot()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_btrfs_call_create_snapshot_finish() to get the result of the operation.
 *
 * See udisks_filesystem_btrfs_call_create_snapshot_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_call_create_snapshot (
    UDisksFilesystemBTRFS *proxy,
    const gchar *arg_source,
    const gchar *arg_dest,
    gboolean arg_ro,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CreateSnapshot",
    g_variant_new ("(ssb@a{sv})",
                   arg_source,
                   arg_dest,
                   arg_ro,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_btrfs_call_create_snapshot_finish:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_btrfs_call_create_snapshot().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_btrfs_call_create_snapshot().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.1.3
 */
gboolean
udisks_filesystem_btrfs_call_create_snapshot_finish (
    UDisksFilesystemBTRFS *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_create_snapshot_sync:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_source: Argument to pass with the method invocation.
 * @arg_dest: Argument to pass with the method invocation.
 * @arg_ro: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.CreateSnapshot">CreateSnapshot()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_btrfs_call_create_snapshot() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.1.3
 */
gboolean
udisks_filesystem_btrfs_call_create_snapshot_sync (
    UDisksFilesystemBTRFS *proxy,
    const gchar *arg_source,
    const gchar *arg_dest,
    gboolean arg_ro,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CreateSnapshot",
    g_variant_new ("(ssb@a{sv})",
                   arg_source,
                   arg_dest,
                   arg_ro,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_repair:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.Repair">Repair()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_btrfs_call_repair_finish() to get the result of the operation.
 *
 * See udisks_filesystem_btrfs_call_repair_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.3.0
 */
void
udisks_filesystem_btrfs_call_repair (
    UDisksFilesystemBTRFS *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Repair",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_btrfs_call_repair_finish:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_btrfs_call_repair().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_btrfs_call_repair().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.3.0
 */
gboolean
udisks_filesystem_btrfs_call_repair_finish (
    UDisksFilesystemBTRFS *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_repair_sync:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.Repair">Repair()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_btrfs_call_repair() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.3.0
 */
gboolean
udisks_filesystem_btrfs_call_repair_sync (
    UDisksFilesystemBTRFS *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Repair",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_resize:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.Resize">Resize()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_btrfs_call_resize_finish() to get the result of the operation.
 *
 * See udisks_filesystem_btrfs_call_resize_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.3.0
 */
void
udisks_filesystem_btrfs_call_resize (
    UDisksFilesystemBTRFS *proxy,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Resize",
    g_variant_new ("(t@a{sv})",
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_btrfs_call_resize_finish:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_btrfs_call_resize().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_btrfs_call_resize().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.3.0
 */
gboolean
udisks_filesystem_btrfs_call_resize_finish (
    UDisksFilesystemBTRFS *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_resize_sync:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.Resize">Resize()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_btrfs_call_resize() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.3.0
 */
gboolean
udisks_filesystem_btrfs_call_resize_sync (
    UDisksFilesystemBTRFS *proxy,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Resize",
    g_variant_new ("(t@a{sv})",
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_set_label:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_label: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.SetLabel">SetLabel()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_btrfs_call_set_label_finish() to get the result of the operation.
 *
 * See udisks_filesystem_btrfs_call_set_label_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_call_set_label (
    UDisksFilesystemBTRFS *proxy,
    const gchar *arg_label,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetLabel",
    g_variant_new ("(s@a{sv})",
                   arg_label,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_btrfs_call_set_label_finish:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_btrfs_call_set_label().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_btrfs_call_set_label().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.1.3
 */
gboolean
udisks_filesystem_btrfs_call_set_label_finish (
    UDisksFilesystemBTRFS *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_set_label_sync:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_label: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.SetLabel">SetLabel()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_btrfs_call_set_label() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.1.3
 */
gboolean
udisks_filesystem_btrfs_call_set_label_sync (
    UDisksFilesystemBTRFS *proxy,
    const gchar *arg_label,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetLabel",
    g_variant_new ("(s@a{sv})",
                   arg_label,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_get_default_subvolume_id:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.GetDefaultSubvolumeID">GetDefaultSubvolumeID()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_btrfs_call_get_default_subvolume_id_finish() to get the result of the operation.
 *
 * See udisks_filesystem_btrfs_call_get_default_subvolume_id_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.11.0
 */
void
udisks_filesystem_btrfs_call_get_default_subvolume_id (
    UDisksFilesystemBTRFS *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "GetDefaultSubvolumeID",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_btrfs_call_get_default_subvolume_id_finish:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @out_id: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_btrfs_call_get_default_subvolume_id().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_btrfs_call_get_default_subvolume_id().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11.0
 */
gboolean
udisks_filesystem_btrfs_call_get_default_subvolume_id_finish (
    UDisksFilesystemBTRFS *proxy,
    guint* out_id,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(u)",
                 out_id);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_get_default_subvolume_id_sync:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @out_id: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.GetDefaultSubvolumeID">GetDefaultSubvolumeID()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_btrfs_call_get_default_subvolume_id() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11.0
 */
gboolean
udisks_filesystem_btrfs_call_get_default_subvolume_id_sync (
    UDisksFilesystemBTRFS *proxy,
    GVariant *arg_options,
    guint* out_id,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "GetDefaultSubvolumeID",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(u)",
                 out_id);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_set_default_subvolume_id:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_id: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.SetDefaultSubvolumeID">SetDefaultSubvolumeID()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_btrfs_call_set_default_subvolume_id_finish() to get the result of the operation.
 *
 * See udisks_filesystem_btrfs_call_set_default_subvolume_id_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.11.0
 */
void
udisks_filesystem_btrfs_call_set_default_subvolume_id (
    UDisksFilesystemBTRFS *proxy,
    guint arg_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "SetDefaultSubvolumeID",
    g_variant_new ("(u@a{sv})",
                   arg_id,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_filesystem_btrfs_call_set_default_subvolume_id_finish:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_btrfs_call_set_default_subvolume_id().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_filesystem_btrfs_call_set_default_subvolume_id().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11.0
 */
gboolean
udisks_filesystem_btrfs_call_set_default_subvolume_id_finish (
    UDisksFilesystemBTRFS *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_call_set_default_subvolume_id_sync:
 * @proxy: A #UDisksFilesystemBTRFSProxy.
 * @arg_id: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.SetDefaultSubvolumeID">SetDefaultSubvolumeID()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_btrfs_call_set_default_subvolume_id() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.11.0
 */
gboolean
udisks_filesystem_btrfs_call_set_default_subvolume_id_sync (
    UDisksFilesystemBTRFS *proxy,
    guint arg_id,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "SetDefaultSubvolumeID",
    g_variant_new ("(u@a{sv})",
                   arg_id,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_filesystem_btrfs_complete_add_device:
 * @object: A #UDisksFilesystemBTRFS.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.AddDevice">AddDevice()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.3.0
 */
void
udisks_filesystem_btrfs_complete_add_device (
    UDisksFilesystemBTRFS *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_filesystem_btrfs_complete_remove_device:
 * @object: A #UDisksFilesystemBTRFS.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.RemoveDevice">RemoveDevice()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.3.0
 */
void
udisks_filesystem_btrfs_complete_remove_device (
    UDisksFilesystemBTRFS *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_filesystem_btrfs_complete_create_subvolume:
 * @object: A #UDisksFilesystemBTRFS.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.CreateSubvolume">CreateSubvolume()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_complete_create_subvolume (
    UDisksFilesystemBTRFS *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_filesystem_btrfs_complete_remove_subvolume:
 * @object: A #UDisksFilesystemBTRFS.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.RemoveSubvolume">RemoveSubvolume()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_complete_remove_subvolume (
    UDisksFilesystemBTRFS *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_filesystem_btrfs_complete_get_subvolumes:
 * @object: A #UDisksFilesystemBTRFS.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @subvolumes: Parameter to return.
 * @subvolumes_cnt: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.GetSubvolumes">GetSubvolumes()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_complete_get_subvolumes (
    UDisksFilesystemBTRFS *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GVariant *subvolumes,
    gint subvolumes_cnt)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(@a(tts)i)",
                   subvolumes,
                   subvolumes_cnt));
}

/**
 * udisks_filesystem_btrfs_complete_create_snapshot:
 * @object: A #UDisksFilesystemBTRFS.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.CreateSnapshot">CreateSnapshot()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_complete_create_snapshot (
    UDisksFilesystemBTRFS *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_filesystem_btrfs_complete_repair:
 * @object: A #UDisksFilesystemBTRFS.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.Repair">Repair()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.3.0
 */
void
udisks_filesystem_btrfs_complete_repair (
    UDisksFilesystemBTRFS *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_filesystem_btrfs_complete_resize:
 * @object: A #UDisksFilesystemBTRFS.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.Resize">Resize()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.3.0
 */
void
udisks_filesystem_btrfs_complete_resize (
    UDisksFilesystemBTRFS *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_filesystem_btrfs_complete_set_label:
 * @object: A #UDisksFilesystemBTRFS.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.SetLabel">SetLabel()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_complete_set_label (
    UDisksFilesystemBTRFS *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_filesystem_btrfs_complete_get_default_subvolume_id:
 * @object: A #UDisksFilesystemBTRFS.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @id: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.GetDefaultSubvolumeID">GetDefaultSubvolumeID()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.11.0
 */
void
udisks_filesystem_btrfs_complete_get_default_subvolume_id (
    UDisksFilesystemBTRFS *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    guint id)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(u)",
                   id));
}

/**
 * udisks_filesystem_btrfs_complete_set_default_subvolume_id:
 * @object: A #UDisksFilesystemBTRFS.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Filesystem-BTRFS.SetDefaultSubvolumeID">SetDefaultSubvolumeID()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.11.0
 */
void
udisks_filesystem_btrfs_complete_set_default_subvolume_id (
    UDisksFilesystemBTRFS *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksFilesystemBTRFSProxy:
 *
 * The #UDisksFilesystemBTRFSProxy structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.1.3
 */

/**
 * UDisksFilesystemBTRFSProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksFilesystemBTRFSProxy.
 *
 * Since: 2.1.3
 */

struct _UDisksFilesystemBTRFSProxyPrivate
{
  GData *qdata;
};

static void udisks_filesystem_btrfs_proxy_iface_init (UDisksFilesystemBTRFSIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksFilesystemBTRFSProxy, udisks_filesystem_btrfs_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksFilesystemBTRFSProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_FILESYSTEM_BTRFS, udisks_filesystem_btrfs_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksFilesystemBTRFSProxy, udisks_filesystem_btrfs_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_FILESYSTEM_BTRFS, udisks_filesystem_btrfs_proxy_iface_init))

#endif
static void
udisks_filesystem_btrfs_proxy_finalize (GObject *object)
{
  UDisksFilesystemBTRFSProxy *proxy = UDISKS_FILESYSTEM_BTRFS_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_filesystem_btrfs_proxy_parent_class)->finalize (object);
}

static void
udisks_filesystem_btrfs_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_filesystem_btrfs_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_filesystem_btrfs_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.Filesystem.BTRFS: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_filesystem_btrfs_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_filesystem_btrfs_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.Filesystem.BTRFS", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_filesystem_btrfs_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_filesystem_btrfs_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_filesystem_btrfs_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_FILESYSTEM_BTRFS);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_FILESYSTEM_BTRFS);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_filesystem_btrfs_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksFilesystemBTRFSProxy *proxy = UDISKS_FILESYSTEM_BTRFS_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_filesystem_btrfs_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_filesystem_btrfs_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_filesystem_btrfs_proxy_get_label (UDisksFilesystemBTRFS *object)
{
  UDisksFilesystemBTRFSProxy *proxy = UDISKS_FILESYSTEM_BTRFS_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "label");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_filesystem_btrfs_proxy_get_uuid (UDisksFilesystemBTRFS *object)
{
  UDisksFilesystemBTRFSProxy *proxy = UDISKS_FILESYSTEM_BTRFS_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "uuid");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_filesystem_btrfs_proxy_get_num_devices (UDisksFilesystemBTRFS *object)
{
  UDisksFilesystemBTRFSProxy *proxy = UDISKS_FILESYSTEM_BTRFS_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "num_devices");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_filesystem_btrfs_proxy_get_used (UDisksFilesystemBTRFS *object)
{
  UDisksFilesystemBTRFSProxy *proxy = UDISKS_FILESYSTEM_BTRFS_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "used");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_filesystem_btrfs_proxy_init (UDisksFilesystemBTRFSProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_filesystem_btrfs_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_FILESYSTEM_BTRFS_PROXY, UDisksFilesystemBTRFSProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_filesystem_btrfs_interface_info ());
}

static void
udisks_filesystem_btrfs_proxy_class_init (UDisksFilesystemBTRFSProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_filesystem_btrfs_proxy_finalize;
  gobject_class->get_property = udisks_filesystem_btrfs_proxy_get_property;
  gobject_class->set_property = udisks_filesystem_btrfs_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_filesystem_btrfs_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_filesystem_btrfs_proxy_g_properties_changed;

  udisks_filesystem_btrfs_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksFilesystemBTRFSProxyPrivate));
#endif
}

static void
udisks_filesystem_btrfs_proxy_iface_init (UDisksFilesystemBTRFSIface *iface)
{
  iface->get_label = udisks_filesystem_btrfs_proxy_get_label;
  iface->get_uuid = udisks_filesystem_btrfs_proxy_get_uuid;
  iface->get_num_devices = udisks_filesystem_btrfs_proxy_get_num_devices;
  iface->get_used = udisks_filesystem_btrfs_proxy_get_used;
}

/**
 * udisks_filesystem_btrfs_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem-BTRFS.top_of_page">org.freedesktop.UDisks2.Filesystem.BTRFS</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_btrfs_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_filesystem_btrfs_proxy_new_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_FILESYSTEM_BTRFS_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Filesystem.BTRFS", NULL);
}

/**
 * udisks_filesystem_btrfs_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_btrfs_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_filesystem_btrfs_proxy_new().
 *
 * Returns: (transfer full) (type UDisksFilesystemBTRFSProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.1.3
 */
UDisksFilesystemBTRFS *
udisks_filesystem_btrfs_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_FILESYSTEM_BTRFS (ret);
  else
    return NULL;
}

/**
 * udisks_filesystem_btrfs_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem-BTRFS.top_of_page">org.freedesktop.UDisks2.Filesystem.BTRFS</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_btrfs_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksFilesystemBTRFSProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.1.3
 */
UDisksFilesystemBTRFS *
udisks_filesystem_btrfs_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_FILESYSTEM_BTRFS_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Filesystem.BTRFS", NULL);
  if (ret != NULL)
    return UDISKS_FILESYSTEM_BTRFS (ret);
  else
    return NULL;
}


/**
 * udisks_filesystem_btrfs_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_filesystem_btrfs_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_filesystem_btrfs_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_filesystem_btrfs_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.1.3
 */
void
udisks_filesystem_btrfs_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_FILESYSTEM_BTRFS_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Filesystem.BTRFS", NULL);
}

/**
 * udisks_filesystem_btrfs_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_filesystem_btrfs_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_filesystem_btrfs_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksFilesystemBTRFSProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.1.3
 */
UDisksFilesystemBTRFS *
udisks_filesystem_btrfs_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_FILESYSTEM_BTRFS (ret);
  else
    return NULL;
}

/**
 * udisks_filesystem_btrfs_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_filesystem_btrfs_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_filesystem_btrfs_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksFilesystemBTRFSProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.1.3
 */
UDisksFilesystemBTRFS *
udisks_filesystem_btrfs_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_FILESYSTEM_BTRFS_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Filesystem.BTRFS", NULL);
  if (ret != NULL)
    return UDISKS_FILESYSTEM_BTRFS (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksFilesystemBTRFSSkeleton:
 *
 * The #UDisksFilesystemBTRFSSkeleton structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.1.3
 */

/**
 * UDisksFilesystemBTRFSSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksFilesystemBTRFSSkeleton.
 *
 * Since: 2.1.3
 */

struct _UDisksFilesystemBTRFSSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_filesystem_btrfs_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_FILESYSTEM_BTRFS);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_FILESYSTEM_BTRFS);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_filesystem_btrfs_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_filesystem_btrfs_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_filesystem_btrfs_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_filesystem_btrfs_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_filesystem_btrfs_skeleton_vtable =
{
  _udisks_filesystem_btrfs_skeleton_handle_method_call,
  _udisks_filesystem_btrfs_skeleton_handle_get_property,
  _udisks_filesystem_btrfs_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_filesystem_btrfs_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_filesystem_btrfs_interface_info ();
}

static GDBusInterfaceVTable *
udisks_filesystem_btrfs_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_filesystem_btrfs_skeleton_vtable;
}

static GVariant *
udisks_filesystem_btrfs_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_filesystem_btrfs_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_filesystem_btrfs_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_filesystem_btrfs_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_filesystem_btrfs_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Filesystem.BTRFS", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_filesystem_btrfs_emit_changed (gpointer user_data);

static void
udisks_filesystem_btrfs_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_filesystem_btrfs_emit_changed (skeleton);
}

static void udisks_filesystem_btrfs_skeleton_iface_init (UDisksFilesystemBTRFSIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksFilesystemBTRFSSkeleton, udisks_filesystem_btrfs_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksFilesystemBTRFSSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_FILESYSTEM_BTRFS, udisks_filesystem_btrfs_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksFilesystemBTRFSSkeleton, udisks_filesystem_btrfs_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_FILESYSTEM_BTRFS, udisks_filesystem_btrfs_skeleton_iface_init))

#endif
static void
udisks_filesystem_btrfs_skeleton_finalize (GObject *object)
{
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (object);
  guint n;
  for (n = 0; n < 4; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_filesystem_btrfs_skeleton_parent_class)->finalize (object);
}

static void
udisks_filesystem_btrfs_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_filesystem_btrfs_emit_changed (gpointer user_data)
{
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.Filesystem.BTRFS",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_filesystem_btrfs_schedule_emit_changed (UDisksFilesystemBTRFSSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_filesystem_btrfs_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_filesystem_btrfs_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_filesystem_btrfs_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_filesystem_btrfs_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 4);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_filesystem_btrfs_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_filesystem_btrfs_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_filesystem_btrfs_skeleton_init (UDisksFilesystemBTRFSSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_filesystem_btrfs_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_FILESYSTEM_BTRFS_SKELETON, UDisksFilesystemBTRFSSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 4);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_UINT64);
}

static const gchar *
udisks_filesystem_btrfs_skeleton_get_label (UDisksFilesystemBTRFS *object)
{
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_filesystem_btrfs_skeleton_get_uuid (UDisksFilesystemBTRFS *object)
{
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_filesystem_btrfs_skeleton_get_num_devices (UDisksFilesystemBTRFS *object)
{
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_filesystem_btrfs_skeleton_get_used (UDisksFilesystemBTRFS *object)
{
  UDisksFilesystemBTRFSSkeleton *skeleton = UDISKS_FILESYSTEM_BTRFS_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_filesystem_btrfs_skeleton_class_init (UDisksFilesystemBTRFSSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_filesystem_btrfs_skeleton_finalize;
  gobject_class->get_property = udisks_filesystem_btrfs_skeleton_get_property;
  gobject_class->set_property = udisks_filesystem_btrfs_skeleton_set_property;
  gobject_class->notify       = udisks_filesystem_btrfs_skeleton_notify;


  udisks_filesystem_btrfs_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_filesystem_btrfs_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_filesystem_btrfs_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_filesystem_btrfs_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_filesystem_btrfs_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksFilesystemBTRFSSkeletonPrivate));
#endif
}

static void
udisks_filesystem_btrfs_skeleton_iface_init (UDisksFilesystemBTRFSIface *iface)
{
  iface->get_label = udisks_filesystem_btrfs_skeleton_get_label;
  iface->get_uuid = udisks_filesystem_btrfs_skeleton_get_uuid;
  iface->get_num_devices = udisks_filesystem_btrfs_skeleton_get_num_devices;
  iface->get_used = udisks_filesystem_btrfs_skeleton_get_used;
}

/**
 * udisks_filesystem_btrfs_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem-BTRFS.top_of_page">org.freedesktop.UDisks2.Filesystem.BTRFS</link>.
 *
 * Returns: (transfer full) (type UDisksFilesystemBTRFSSkeleton): The skeleton object.
 *
 * Since: 2.1.3
 */
UDisksFilesystemBTRFS *
udisks_filesystem_btrfs_skeleton_new (void)
{
  return UDISKS_FILESYSTEM_BTRFS (g_object_new (UDISKS_TYPE_FILESYSTEM_BTRFS_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Manager.LVM2
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksManagerLVM2
 * @title: UDisksManagerLVM2
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Manager.LVM2 D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-LVM2.top_of_page">org.freedesktop.UDisks2.Manager.LVM2</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Manager.LVM2 ---- */

static const _ExtendedGDBusArgInfo _udisks_manager_lvm2_method_info_volume_group_create_IN_ARG_name =
{
  {
    -1,
    (gchar *) "name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_lvm2_method_info_volume_group_create_IN_ARG_blocks =
{
  {
    -1,
    (gchar *) "blocks",
    (gchar *) "ao",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_manager_lvm2_method_info_volume_group_create_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_lvm2_method_info_volume_group_create_IN_ARG_pointers[] =
{
  &_udisks_manager_lvm2_method_info_volume_group_create_IN_ARG_name.parent_struct,
  &_udisks_manager_lvm2_method_info_volume_group_create_IN_ARG_blocks.parent_struct,
  &_udisks_manager_lvm2_method_info_volume_group_create_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_manager_lvm2_method_info_volume_group_create_OUT_ARG_result =
{
  {
    -1,
    (gchar *) "result",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_manager_lvm2_method_info_volume_group_create_OUT_ARG_pointers[] =
{
  &_udisks_manager_lvm2_method_info_volume_group_create_OUT_ARG_result.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_manager_lvm2_method_info_volume_group_create =
{
  {
    -1,
    (gchar *) "VolumeGroupCreate",
    (GDBusArgInfo **) &_udisks_manager_lvm2_method_info_volume_group_create_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_manager_lvm2_method_info_volume_group_create_OUT_ARG_pointers,
    NULL
  },
  "handle-volume-group-create",
  FALSE
};

static const GDBusMethodInfo * const _udisks_manager_lvm2_method_info_pointers[] =
{
  &_udisks_manager_lvm2_method_info_volume_group_create.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_manager_lvm2_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Manager.LVM2",
    (GDBusMethodInfo **) &_udisks_manager_lvm2_method_info_pointers,
    NULL,
    NULL,
    NULL
  },
  "manager-lvm2",
};


/**
 * udisks_manager_lvm2_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-LVM2.top_of_page">org.freedesktop.UDisks2.Manager.LVM2</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 *
 * Since: 2.0.0
 */
GDBusInterfaceInfo *
udisks_manager_lvm2_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_manager_lvm2_interface_info.parent_struct;
}

/**
 * udisks_manager_lvm2_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksManagerLVM2 interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 *
 * Since: 2.0.0
 */
guint
udisks_manager_lvm2_override_properties (GObjectClass *klass G_GNUC_UNUSED, guint property_id_begin)
{
  return property_id_begin - 1;
}


inline static void
udisks_manager_lvm2_method_marshal_volume_group_create (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_BOXED_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksManagerLVM2:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-LVM2.top_of_page">org.freedesktop.UDisks2.Manager.LVM2</link>.
 *
 * Since: 2.0.0
 */

/**
 * UDisksManagerLVM2Iface:
 * @parent_iface: The parent interface.
 * @handle_volume_group_create: Handler for the #UDisksManagerLVM2::handle-volume-group-create signal.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-LVM2.top_of_page">org.freedesktop.UDisks2.Manager.LVM2</link>.
 *
 * Since: 2.0.0
 */

typedef UDisksManagerLVM2Iface UDisksManagerLVM2Interface;
G_DEFINE_INTERFACE (UDisksManagerLVM2, udisks_manager_lvm2, G_TYPE_OBJECT)

static void
udisks_manager_lvm2_default_init (UDisksManagerLVM2Iface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksManagerLVM2::handle-volume-group-create:
   * @object: A #UDisksManagerLVM2.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_name: Argument passed by remote caller.
   * @arg_blocks: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-LVM2.VolumeGroupCreate">VolumeGroupCreate()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_manager_lvm2_complete_volume_group_create() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-volume-group-create",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksManagerLVM2Iface, handle_volume_group_create),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_manager_lvm2_method_marshal_volume_group_create,
    G_TYPE_BOOLEAN,
    4,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRV, G_TYPE_VARIANT);

}

/**
 * udisks_manager_lvm2_call_volume_group_create:
 * @proxy: A #UDisksManagerLVM2Proxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_blocks: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-LVM2.VolumeGroupCreate">VolumeGroupCreate()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_lvm2_call_volume_group_create_finish() to get the result of the operation.
 *
 * See udisks_manager_lvm2_call_volume_group_create_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_manager_lvm2_call_volume_group_create (
    UDisksManagerLVM2 *proxy,
    const gchar *arg_name,
    const gchar *const *arg_blocks,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "VolumeGroupCreate",
    g_variant_new ("(s^ao@a{sv})",
                   arg_name,
                   arg_blocks,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_manager_lvm2_call_volume_group_create_finish:
 * @proxy: A #UDisksManagerLVM2Proxy.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_lvm2_call_volume_group_create().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_manager_lvm2_call_volume_group_create().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_manager_lvm2_call_volume_group_create_finish (
    UDisksManagerLVM2 *proxy,
    gchar ** out_result,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_lvm2_call_volume_group_create_sync:
 * @proxy: A #UDisksManagerLVM2Proxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_blocks: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-LVM2.VolumeGroupCreate">VolumeGroupCreate()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_lvm2_call_volume_group_create() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_manager_lvm2_call_volume_group_create_sync (
    UDisksManagerLVM2 *proxy,
    const gchar *arg_name,
    const gchar *const *arg_blocks,
    GVariant *arg_options,
    gchar ** out_result,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "VolumeGroupCreate",
    g_variant_new ("(s^ao@a{sv})",
                   arg_name,
                   arg_blocks,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_manager_lvm2_complete_volume_group_create:
 * @object: A #UDisksManagerLVM2.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @result: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-Manager-LVM2.VolumeGroupCreate">VolumeGroupCreate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_manager_lvm2_complete_volume_group_create (
    UDisksManagerLVM2 *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *result)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   result));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksManagerLVM2Proxy:
 *
 * The #UDisksManagerLVM2Proxy structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.0.0
 */

/**
 * UDisksManagerLVM2ProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksManagerLVM2Proxy.
 *
 * Since: 2.0.0
 */

struct _UDisksManagerLVM2ProxyPrivate
{
  GData *qdata;
};

static void udisks_manager_lvm2_proxy_iface_init (UDisksManagerLVM2Iface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksManagerLVM2Proxy, udisks_manager_lvm2_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksManagerLVM2Proxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER_LVM2, udisks_manager_lvm2_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksManagerLVM2Proxy, udisks_manager_lvm2_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER_LVM2, udisks_manager_lvm2_proxy_iface_init))

#endif
static void
udisks_manager_lvm2_proxy_finalize (GObject *object)
{
  UDisksManagerLVM2Proxy *proxy = UDISKS_MANAGER_LVM2_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_manager_lvm2_proxy_parent_class)->finalize (object);
}

static void
udisks_manager_lvm2_proxy_get_property (GObject      *object G_GNUC_UNUSED,
  guint         prop_id G_GNUC_UNUSED,
  GValue       *value G_GNUC_UNUSED,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
}

static void
udisks_manager_lvm2_proxy_set_property (GObject      *object G_GNUC_UNUSED,
  guint         prop_id G_GNUC_UNUSED,
  const GValue *value G_GNUC_UNUSED,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
}

static void
udisks_manager_lvm2_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_manager_lvm2_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_MANAGER_LVM2);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_MANAGER_LVM2);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_manager_lvm2_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksManagerLVM2Proxy *proxy = UDISKS_MANAGER_LVM2_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_lvm2_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_lvm2_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static void
udisks_manager_lvm2_proxy_init (UDisksManagerLVM2Proxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_manager_lvm2_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_MANAGER_LVM2_PROXY, UDisksManagerLVM2ProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_manager_lvm2_interface_info ());
}

static void
udisks_manager_lvm2_proxy_class_init (UDisksManagerLVM2ProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_manager_lvm2_proxy_finalize;
  gobject_class->get_property = udisks_manager_lvm2_proxy_get_property;
  gobject_class->set_property = udisks_manager_lvm2_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_manager_lvm2_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_manager_lvm2_proxy_g_properties_changed;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksManagerLVM2ProxyPrivate));
#endif
}

static void
udisks_manager_lvm2_proxy_iface_init (UDisksManagerLVM2Iface *iface G_GNUC_UNUSED)
{
}

/**
 * udisks_manager_lvm2_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-LVM2.top_of_page">org.freedesktop.UDisks2.Manager.LVM2</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_lvm2_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_manager_lvm2_proxy_new_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.0.0
 */
void
udisks_manager_lvm2_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_MANAGER_LVM2_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager.LVM2", NULL);
}

/**
 * udisks_manager_lvm2_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_lvm2_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_manager_lvm2_proxy_new().
 *
 * Returns: (transfer full) (type UDisksManagerLVM2Proxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksManagerLVM2 *
udisks_manager_lvm2_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_MANAGER_LVM2 (ret);
  else
    return NULL;
}

/**
 * udisks_manager_lvm2_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-LVM2.top_of_page">org.freedesktop.UDisks2.Manager.LVM2</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_lvm2_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksManagerLVM2Proxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksManagerLVM2 *
udisks_manager_lvm2_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_MANAGER_LVM2_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager.LVM2", NULL);
  if (ret != NULL)
    return UDISKS_MANAGER_LVM2 (ret);
  else
    return NULL;
}


/**
 * udisks_manager_lvm2_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_manager_lvm2_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_manager_lvm2_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_manager_lvm2_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.0.0
 */
void
udisks_manager_lvm2_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_MANAGER_LVM2_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager.LVM2", NULL);
}

/**
 * udisks_manager_lvm2_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_manager_lvm2_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_manager_lvm2_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksManagerLVM2Proxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksManagerLVM2 *
udisks_manager_lvm2_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_MANAGER_LVM2 (ret);
  else
    return NULL;
}

/**
 * udisks_manager_lvm2_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_manager_lvm2_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_manager_lvm2_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksManagerLVM2Proxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksManagerLVM2 *
udisks_manager_lvm2_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_MANAGER_LVM2_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Manager.LVM2", NULL);
  if (ret != NULL)
    return UDISKS_MANAGER_LVM2 (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksManagerLVM2Skeleton:
 *
 * The #UDisksManagerLVM2Skeleton structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.0.0
 */

/**
 * UDisksManagerLVM2SkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksManagerLVM2Skeleton.
 *
 * Since: 2.0.0
 */

struct _UDisksManagerLVM2SkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_manager_lvm2_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksManagerLVM2Skeleton *skeleton = UDISKS_MANAGER_LVM2_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_MANAGER_LVM2);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_MANAGER_LVM2);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_manager_lvm2_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksManagerLVM2Skeleton *skeleton = UDISKS_MANAGER_LVM2_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_lvm2_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_manager_lvm2_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksManagerLVM2Skeleton *skeleton = UDISKS_MANAGER_LVM2_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_manager_lvm2_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_manager_lvm2_skeleton_vtable =
{
  _udisks_manager_lvm2_skeleton_handle_method_call,
  _udisks_manager_lvm2_skeleton_handle_get_property,
  _udisks_manager_lvm2_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_manager_lvm2_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_manager_lvm2_interface_info ();
}

static GDBusInterfaceVTable *
udisks_manager_lvm2_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_manager_lvm2_skeleton_vtable;
}

static GVariant *
udisks_manager_lvm2_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksManagerLVM2Skeleton *skeleton = UDISKS_MANAGER_LVM2_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_manager_lvm2_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_manager_lvm2_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_manager_lvm2_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_manager_lvm2_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Manager.LVM2", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static void
udisks_manager_lvm2_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton G_GNUC_UNUSED)
{
}

static void udisks_manager_lvm2_skeleton_iface_init (UDisksManagerLVM2Iface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksManagerLVM2Skeleton, udisks_manager_lvm2_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksManagerLVM2Skeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER_LVM2, udisks_manager_lvm2_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksManagerLVM2Skeleton, udisks_manager_lvm2_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_MANAGER_LVM2, udisks_manager_lvm2_skeleton_iface_init))

#endif
static void
udisks_manager_lvm2_skeleton_finalize (GObject *object)
{
  UDisksManagerLVM2Skeleton *skeleton = UDISKS_MANAGER_LVM2_SKELETON (object);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_manager_lvm2_skeleton_parent_class)->finalize (object);
}

static void
udisks_manager_lvm2_skeleton_init (UDisksManagerLVM2Skeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_manager_lvm2_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_MANAGER_LVM2_SKELETON, UDisksManagerLVM2SkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
}

static void
udisks_manager_lvm2_skeleton_class_init (UDisksManagerLVM2SkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_manager_lvm2_skeleton_finalize;

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_manager_lvm2_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_manager_lvm2_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_manager_lvm2_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_manager_lvm2_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksManagerLVM2SkeletonPrivate));
#endif
}

static void
udisks_manager_lvm2_skeleton_iface_init (UDisksManagerLVM2Iface *iface G_GNUC_UNUSED)
{
}

/**
 * udisks_manager_lvm2_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-LVM2.top_of_page">org.freedesktop.UDisks2.Manager.LVM2</link>.
 *
 * Returns: (transfer full) (type UDisksManagerLVM2Skeleton): The skeleton object.
 *
 * Since: 2.0.0
 */
UDisksManagerLVM2 *
udisks_manager_lvm2_skeleton_new (void)
{
  return UDISKS_MANAGER_LVM2 (g_object_new (UDISKS_TYPE_MANAGER_LVM2_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.Block.LVM2
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksBlockLVM2
 * @title: UDisksBlockLVM2
 * @short_description: Generated C code for the org.freedesktop.UDisks2.Block.LVM2 D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block-LVM2.top_of_page">org.freedesktop.UDisks2.Block.LVM2</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.Block.LVM2 ---- */

static const _ExtendedGDBusPropertyInfo _udisks_block_lvm2_property_info_logical_volume =
{
  {
    -1,
    (gchar *) "LogicalVolume",
    (gchar *) "o",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "logical-volume",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_block_lvm2_property_info_pointers[] =
{
  &_udisks_block_lvm2_property_info_logical_volume.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_block_lvm2_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.Block.LVM2",
    NULL,
    NULL,
    (GDBusPropertyInfo **) &_udisks_block_lvm2_property_info_pointers,
    NULL
  },
  "block-lvm2",
};


/**
 * udisks_block_lvm2_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block-LVM2.top_of_page">org.freedesktop.UDisks2.Block.LVM2</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 *
 * Since: 2.0.0
 */
GDBusInterfaceInfo *
udisks_block_lvm2_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_block_lvm2_interface_info.parent_struct;
}

/**
 * udisks_block_lvm2_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksBlockLVM2 interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 *
 * Since: 2.0.0
 */
guint
udisks_block_lvm2_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "logical-volume");
  return property_id_begin - 1;
}



/**
 * UDisksBlockLVM2:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block-LVM2.top_of_page">org.freedesktop.UDisks2.Block.LVM2</link>.
 *
 * Since: 2.0.0
 */

/**
 * UDisksBlockLVM2Iface:
 * @parent_iface: The parent interface.
 * @get_logical_volume: Getter for the #UDisksBlockLVM2:logical-volume property.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block-LVM2.top_of_page">org.freedesktop.UDisks2.Block.LVM2</link>.
 *
 * Since: 2.0.0
 */

typedef UDisksBlockLVM2Iface UDisksBlockLVM2Interface;
G_DEFINE_INTERFACE (UDisksBlockLVM2, udisks_block_lvm2, G_TYPE_OBJECT)

static void
udisks_block_lvm2_default_init (UDisksBlockLVM2Iface *iface)
{
  /* GObject properties for D-Bus properties: */
  /**
   * UDisksBlockLVM2:logical-volume:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-Block-LVM2.LogicalVolume">"LogicalVolume"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("logical-volume", "LogicalVolume", "LogicalVolume", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_block_lvm2_get_logical_volume: (skip)
 * @object: A #UDisksBlockLVM2.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block-LVM2.LogicalVolume">"LogicalVolume"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_block_lvm2_dup_logical_volume() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_block_lvm2_get_logical_volume (UDisksBlockLVM2 *object)
{
  g_return_val_if_fail (UDISKS_IS_BLOCK_LVM2 (object), NULL);

  return UDISKS_BLOCK_LVM2_GET_IFACE (object)->get_logical_volume (object);
}

/**
 * udisks_block_lvm2_dup_logical_volume: (skip)
 * @object: A #UDisksBlockLVM2.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block-LVM2.LogicalVolume">"LogicalVolume"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_block_lvm2_dup_logical_volume (UDisksBlockLVM2 *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "logical-volume", &value, NULL);
  return value;
}

/**
 * udisks_block_lvm2_set_logical_volume: (skip)
 * @object: A #UDisksBlockLVM2.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-Block-LVM2.LogicalVolume">"LogicalVolume"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_block_lvm2_set_logical_volume (UDisksBlockLVM2 *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "logical-volume", value, NULL);
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksBlockLVM2Proxy:
 *
 * The #UDisksBlockLVM2Proxy structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.0.0
 */

/**
 * UDisksBlockLVM2ProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksBlockLVM2Proxy.
 *
 * Since: 2.0.0
 */

struct _UDisksBlockLVM2ProxyPrivate
{
  GData *qdata;
};

static void udisks_block_lvm2_proxy_iface_init (UDisksBlockLVM2Iface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksBlockLVM2Proxy, udisks_block_lvm2_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksBlockLVM2Proxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_BLOCK_LVM2, udisks_block_lvm2_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksBlockLVM2Proxy, udisks_block_lvm2_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_BLOCK_LVM2, udisks_block_lvm2_proxy_iface_init))

#endif
static void
udisks_block_lvm2_proxy_finalize (GObject *object)
{
  UDisksBlockLVM2Proxy *proxy = UDISKS_BLOCK_LVM2_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_block_lvm2_proxy_parent_class)->finalize (object);
}

static void
udisks_block_lvm2_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 1);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_block_lvm2_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_block_lvm2_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.Block.LVM2: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_block_lvm2_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 1);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_block_lvm2_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.Block.LVM2", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_block_lvm2_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_block_lvm2_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_block_lvm2_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_BLOCK_LVM2);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_BLOCK_LVM2);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_block_lvm2_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksBlockLVM2Proxy *proxy = UDISKS_BLOCK_LVM2_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_block_lvm2_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_block_lvm2_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_block_lvm2_proxy_get_logical_volume (UDisksBlockLVM2 *object)
{
  UDisksBlockLVM2Proxy *proxy = UDISKS_BLOCK_LVM2_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "LogicalVolume");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_block_lvm2_proxy_init (UDisksBlockLVM2Proxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_block_lvm2_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_BLOCK_LVM2_PROXY, UDisksBlockLVM2ProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_block_lvm2_interface_info ());
}

static void
udisks_block_lvm2_proxy_class_init (UDisksBlockLVM2ProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_block_lvm2_proxy_finalize;
  gobject_class->get_property = udisks_block_lvm2_proxy_get_property;
  gobject_class->set_property = udisks_block_lvm2_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_block_lvm2_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_block_lvm2_proxy_g_properties_changed;

  udisks_block_lvm2_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksBlockLVM2ProxyPrivate));
#endif
}

static void
udisks_block_lvm2_proxy_iface_init (UDisksBlockLVM2Iface *iface)
{
  iface->get_logical_volume = udisks_block_lvm2_proxy_get_logical_volume;
}

/**
 * udisks_block_lvm2_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block-LVM2.top_of_page">org.freedesktop.UDisks2.Block.LVM2</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_lvm2_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_block_lvm2_proxy_new_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.0.0
 */
void
udisks_block_lvm2_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_BLOCK_LVM2_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Block.LVM2", NULL);
}

/**
 * udisks_block_lvm2_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_lvm2_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_block_lvm2_proxy_new().
 *
 * Returns: (transfer full) (type UDisksBlockLVM2Proxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksBlockLVM2 *
udisks_block_lvm2_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_BLOCK_LVM2 (ret);
  else
    return NULL;
}

/**
 * udisks_block_lvm2_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block-LVM2.top_of_page">org.freedesktop.UDisks2.Block.LVM2</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_block_lvm2_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksBlockLVM2Proxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksBlockLVM2 *
udisks_block_lvm2_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_BLOCK_LVM2_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Block.LVM2", NULL);
  if (ret != NULL)
    return UDISKS_BLOCK_LVM2 (ret);
  else
    return NULL;
}


/**
 * udisks_block_lvm2_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_block_lvm2_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_block_lvm2_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_block_lvm2_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.0.0
 */
void
udisks_block_lvm2_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_BLOCK_LVM2_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Block.LVM2", NULL);
}

/**
 * udisks_block_lvm2_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_block_lvm2_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_block_lvm2_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksBlockLVM2Proxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksBlockLVM2 *
udisks_block_lvm2_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_BLOCK_LVM2 (ret);
  else
    return NULL;
}

/**
 * udisks_block_lvm2_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_block_lvm2_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_block_lvm2_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksBlockLVM2Proxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksBlockLVM2 *
udisks_block_lvm2_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_BLOCK_LVM2_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.Block.LVM2", NULL);
  if (ret != NULL)
    return UDISKS_BLOCK_LVM2 (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksBlockLVM2Skeleton:
 *
 * The #UDisksBlockLVM2Skeleton structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.0.0
 */

/**
 * UDisksBlockLVM2SkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksBlockLVM2Skeleton.
 *
 * Since: 2.0.0
 */

struct _UDisksBlockLVM2SkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_block_lvm2_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksBlockLVM2Skeleton *skeleton = UDISKS_BLOCK_LVM2_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_BLOCK_LVM2);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_BLOCK_LVM2);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_block_lvm2_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksBlockLVM2Skeleton *skeleton = UDISKS_BLOCK_LVM2_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_block_lvm2_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_block_lvm2_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksBlockLVM2Skeleton *skeleton = UDISKS_BLOCK_LVM2_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_block_lvm2_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_block_lvm2_skeleton_vtable =
{
  _udisks_block_lvm2_skeleton_handle_method_call,
  _udisks_block_lvm2_skeleton_handle_get_property,
  _udisks_block_lvm2_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_block_lvm2_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_block_lvm2_interface_info ();
}

static GDBusInterfaceVTable *
udisks_block_lvm2_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_block_lvm2_skeleton_vtable;
}

static GVariant *
udisks_block_lvm2_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksBlockLVM2Skeleton *skeleton = UDISKS_BLOCK_LVM2_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_block_lvm2_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_block_lvm2_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_block_lvm2_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_block_lvm2_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.Block.LVM2", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_block_lvm2_emit_changed (gpointer user_data);

static void
udisks_block_lvm2_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksBlockLVM2Skeleton *skeleton = UDISKS_BLOCK_LVM2_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_block_lvm2_emit_changed (skeleton);
}

static void udisks_block_lvm2_skeleton_iface_init (UDisksBlockLVM2Iface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksBlockLVM2Skeleton, udisks_block_lvm2_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksBlockLVM2Skeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_BLOCK_LVM2, udisks_block_lvm2_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksBlockLVM2Skeleton, udisks_block_lvm2_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_BLOCK_LVM2, udisks_block_lvm2_skeleton_iface_init))

#endif
static void
udisks_block_lvm2_skeleton_finalize (GObject *object)
{
  UDisksBlockLVM2Skeleton *skeleton = UDISKS_BLOCK_LVM2_SKELETON (object);
  guint n;
  for (n = 0; n < 1; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_block_lvm2_skeleton_parent_class)->finalize (object);
}

static void
udisks_block_lvm2_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksBlockLVM2Skeleton *skeleton = UDISKS_BLOCK_LVM2_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 1);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_block_lvm2_emit_changed (gpointer user_data)
{
  UDisksBlockLVM2Skeleton *skeleton = UDISKS_BLOCK_LVM2_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.Block.LVM2",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_block_lvm2_schedule_emit_changed (UDisksBlockLVM2Skeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_block_lvm2_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksBlockLVM2Skeleton *skeleton = UDISKS_BLOCK_LVM2_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_block_lvm2_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_block_lvm2_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_block_lvm2_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksBlockLVM2Skeleton *skeleton = UDISKS_BLOCK_LVM2_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 1);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_block_lvm2_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_block_lvm2_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_block_lvm2_skeleton_init (UDisksBlockLVM2Skeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_block_lvm2_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_BLOCK_LVM2_SKELETON, UDisksBlockLVM2SkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 1);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
}

static const gchar *
udisks_block_lvm2_skeleton_get_logical_volume (UDisksBlockLVM2 *object)
{
  UDisksBlockLVM2Skeleton *skeleton = UDISKS_BLOCK_LVM2_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_block_lvm2_skeleton_class_init (UDisksBlockLVM2SkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_block_lvm2_skeleton_finalize;
  gobject_class->get_property = udisks_block_lvm2_skeleton_get_property;
  gobject_class->set_property = udisks_block_lvm2_skeleton_set_property;
  gobject_class->notify       = udisks_block_lvm2_skeleton_notify;


  udisks_block_lvm2_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_block_lvm2_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_block_lvm2_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_block_lvm2_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_block_lvm2_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksBlockLVM2SkeletonPrivate));
#endif
}

static void
udisks_block_lvm2_skeleton_iface_init (UDisksBlockLVM2Iface *iface)
{
  iface->get_logical_volume = udisks_block_lvm2_skeleton_get_logical_volume;
}

/**
 * udisks_block_lvm2_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block-LVM2.top_of_page">org.freedesktop.UDisks2.Block.LVM2</link>.
 *
 * Returns: (transfer full) (type UDisksBlockLVM2Skeleton): The skeleton object.
 *
 * Since: 2.0.0
 */
UDisksBlockLVM2 *
udisks_block_lvm2_skeleton_new (void)
{
  return UDISKS_BLOCK_LVM2 (g_object_new (UDISKS_TYPE_BLOCK_LVM2_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.PhysicalVolume
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksPhysicalVolume
 * @title: UDisksPhysicalVolume
 * @short_description: Generated C code for the org.freedesktop.UDisks2.PhysicalVolume D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-PhysicalVolume.top_of_page">org.freedesktop.UDisks2.PhysicalVolume</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.PhysicalVolume ---- */

static const _ExtendedGDBusPropertyInfo _udisks_physical_volume_property_info_volume_group =
{
  {
    -1,
    (gchar *) "VolumeGroup",
    (gchar *) "o",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "volume-group",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_physical_volume_property_info_size =
{
  {
    -1,
    (gchar *) "Size",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "size",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_physical_volume_property_info_free_size =
{
  {
    -1,
    (gchar *) "FreeSize",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "free-size",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_physical_volume_property_info_pointers[] =
{
  &_udisks_physical_volume_property_info_volume_group.parent_struct,
  &_udisks_physical_volume_property_info_size.parent_struct,
  &_udisks_physical_volume_property_info_free_size.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_physical_volume_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.PhysicalVolume",
    NULL,
    NULL,
    (GDBusPropertyInfo **) &_udisks_physical_volume_property_info_pointers,
    NULL
  },
  "physical-volume",
};


/**
 * udisks_physical_volume_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-PhysicalVolume.top_of_page">org.freedesktop.UDisks2.PhysicalVolume</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 *
 * Since: 2.0.0
 */
GDBusInterfaceInfo *
udisks_physical_volume_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_physical_volume_interface_info.parent_struct;
}

/**
 * udisks_physical_volume_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksPhysicalVolume interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 *
 * Since: 2.0.0
 */
guint
udisks_physical_volume_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "volume-group");
  g_object_class_override_property (klass, property_id_begin++, "size");
  g_object_class_override_property (klass, property_id_begin++, "free-size");
  return property_id_begin - 1;
}



/**
 * UDisksPhysicalVolume:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PhysicalVolume.top_of_page">org.freedesktop.UDisks2.PhysicalVolume</link>.
 *
 * Since: 2.0.0
 */

/**
 * UDisksPhysicalVolumeIface:
 * @parent_iface: The parent interface.
 * @get_free_size: Getter for the #UDisksPhysicalVolume:free-size property.
 * @get_size: Getter for the #UDisksPhysicalVolume:size property.
 * @get_volume_group: Getter for the #UDisksPhysicalVolume:volume-group property.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PhysicalVolume.top_of_page">org.freedesktop.UDisks2.PhysicalVolume</link>.
 *
 * Since: 2.0.0
 */

typedef UDisksPhysicalVolumeIface UDisksPhysicalVolumeInterface;
G_DEFINE_INTERFACE (UDisksPhysicalVolume, udisks_physical_volume, G_TYPE_OBJECT)

static void
udisks_physical_volume_default_init (UDisksPhysicalVolumeIface *iface)
{
  /* GObject properties for D-Bus properties: */
  /**
   * UDisksPhysicalVolume:volume-group:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-PhysicalVolume.VolumeGroup">"VolumeGroup"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("volume-group", "VolumeGroup", "VolumeGroup", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksPhysicalVolume:size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-PhysicalVolume.Size">"Size"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("size", "Size", "Size", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksPhysicalVolume:free-size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-PhysicalVolume.FreeSize">"FreeSize"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("free-size", "FreeSize", "FreeSize", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_physical_volume_get_volume_group: (skip)
 * @object: A #UDisksPhysicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-PhysicalVolume.VolumeGroup">"VolumeGroup"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_physical_volume_dup_volume_group() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_physical_volume_get_volume_group (UDisksPhysicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_PHYSICAL_VOLUME (object), NULL);

  return UDISKS_PHYSICAL_VOLUME_GET_IFACE (object)->get_volume_group (object);
}

/**
 * udisks_physical_volume_dup_volume_group: (skip)
 * @object: A #UDisksPhysicalVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-PhysicalVolume.VolumeGroup">"VolumeGroup"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_physical_volume_dup_volume_group (UDisksPhysicalVolume *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "volume-group", &value, NULL);
  return value;
}

/**
 * udisks_physical_volume_set_volume_group: (skip)
 * @object: A #UDisksPhysicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-PhysicalVolume.VolumeGroup">"VolumeGroup"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_physical_volume_set_volume_group (UDisksPhysicalVolume *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "volume-group", value, NULL);
}

/**
 * udisks_physical_volume_get_size: (skip)
 * @object: A #UDisksPhysicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-PhysicalVolume.Size">"Size"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
guint64 
udisks_physical_volume_get_size (UDisksPhysicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_PHYSICAL_VOLUME (object), 0);

  return UDISKS_PHYSICAL_VOLUME_GET_IFACE (object)->get_size (object);
}

/**
 * udisks_physical_volume_set_size: (skip)
 * @object: A #UDisksPhysicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-PhysicalVolume.Size">"Size"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_physical_volume_set_size (UDisksPhysicalVolume *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "size", value, NULL);
}

/**
 * udisks_physical_volume_get_free_size: (skip)
 * @object: A #UDisksPhysicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-PhysicalVolume.FreeSize">"FreeSize"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
guint64 
udisks_physical_volume_get_free_size (UDisksPhysicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_PHYSICAL_VOLUME (object), 0);

  return UDISKS_PHYSICAL_VOLUME_GET_IFACE (object)->get_free_size (object);
}

/**
 * udisks_physical_volume_set_free_size: (skip)
 * @object: A #UDisksPhysicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-PhysicalVolume.FreeSize">"FreeSize"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_physical_volume_set_free_size (UDisksPhysicalVolume *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "free-size", value, NULL);
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksPhysicalVolumeProxy:
 *
 * The #UDisksPhysicalVolumeProxy structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.0.0
 */

/**
 * UDisksPhysicalVolumeProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksPhysicalVolumeProxy.
 *
 * Since: 2.0.0
 */

struct _UDisksPhysicalVolumeProxyPrivate
{
  GData *qdata;
};

static void udisks_physical_volume_proxy_iface_init (UDisksPhysicalVolumeIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksPhysicalVolumeProxy, udisks_physical_volume_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksPhysicalVolumeProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_PHYSICAL_VOLUME, udisks_physical_volume_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksPhysicalVolumeProxy, udisks_physical_volume_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_PHYSICAL_VOLUME, udisks_physical_volume_proxy_iface_init))

#endif
static void
udisks_physical_volume_proxy_finalize (GObject *object)
{
  UDisksPhysicalVolumeProxy *proxy = UDISKS_PHYSICAL_VOLUME_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_physical_volume_proxy_parent_class)->finalize (object);
}

static void
udisks_physical_volume_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 3);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_physical_volume_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_physical_volume_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.PhysicalVolume: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_physical_volume_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 3);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_physical_volume_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.PhysicalVolume", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_physical_volume_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_physical_volume_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_physical_volume_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_PHYSICAL_VOLUME);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_PHYSICAL_VOLUME);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_physical_volume_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksPhysicalVolumeProxy *proxy = UDISKS_PHYSICAL_VOLUME_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_physical_volume_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_physical_volume_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_physical_volume_proxy_get_volume_group (UDisksPhysicalVolume *object)
{
  UDisksPhysicalVolumeProxy *proxy = UDISKS_PHYSICAL_VOLUME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "VolumeGroup");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_physical_volume_proxy_get_size (UDisksPhysicalVolume *object)
{
  UDisksPhysicalVolumeProxy *proxy = UDISKS_PHYSICAL_VOLUME_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Size");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_physical_volume_proxy_get_free_size (UDisksPhysicalVolume *object)
{
  UDisksPhysicalVolumeProxy *proxy = UDISKS_PHYSICAL_VOLUME_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "FreeSize");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_physical_volume_proxy_init (UDisksPhysicalVolumeProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_physical_volume_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_PHYSICAL_VOLUME_PROXY, UDisksPhysicalVolumeProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_physical_volume_interface_info ());
}

static void
udisks_physical_volume_proxy_class_init (UDisksPhysicalVolumeProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_physical_volume_proxy_finalize;
  gobject_class->get_property = udisks_physical_volume_proxy_get_property;
  gobject_class->set_property = udisks_physical_volume_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_physical_volume_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_physical_volume_proxy_g_properties_changed;

  udisks_physical_volume_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksPhysicalVolumeProxyPrivate));
#endif
}

static void
udisks_physical_volume_proxy_iface_init (UDisksPhysicalVolumeIface *iface)
{
  iface->get_volume_group = udisks_physical_volume_proxy_get_volume_group;
  iface->get_size = udisks_physical_volume_proxy_get_size;
  iface->get_free_size = udisks_physical_volume_proxy_get_free_size;
}

/**
 * udisks_physical_volume_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PhysicalVolume.top_of_page">org.freedesktop.UDisks2.PhysicalVolume</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_physical_volume_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_physical_volume_proxy_new_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.0.0
 */
void
udisks_physical_volume_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_PHYSICAL_VOLUME_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.PhysicalVolume", NULL);
}

/**
 * udisks_physical_volume_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_physical_volume_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_physical_volume_proxy_new().
 *
 * Returns: (transfer full) (type UDisksPhysicalVolumeProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksPhysicalVolume *
udisks_physical_volume_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_PHYSICAL_VOLUME (ret);
  else
    return NULL;
}

/**
 * udisks_physical_volume_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PhysicalVolume.top_of_page">org.freedesktop.UDisks2.PhysicalVolume</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_physical_volume_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksPhysicalVolumeProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksPhysicalVolume *
udisks_physical_volume_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_PHYSICAL_VOLUME_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.PhysicalVolume", NULL);
  if (ret != NULL)
    return UDISKS_PHYSICAL_VOLUME (ret);
  else
    return NULL;
}


/**
 * udisks_physical_volume_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_physical_volume_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_physical_volume_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_physical_volume_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.0.0
 */
void
udisks_physical_volume_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_PHYSICAL_VOLUME_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.PhysicalVolume", NULL);
}

/**
 * udisks_physical_volume_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_physical_volume_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_physical_volume_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksPhysicalVolumeProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksPhysicalVolume *
udisks_physical_volume_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_PHYSICAL_VOLUME (ret);
  else
    return NULL;
}

/**
 * udisks_physical_volume_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_physical_volume_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_physical_volume_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksPhysicalVolumeProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksPhysicalVolume *
udisks_physical_volume_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_PHYSICAL_VOLUME_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.PhysicalVolume", NULL);
  if (ret != NULL)
    return UDISKS_PHYSICAL_VOLUME (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksPhysicalVolumeSkeleton:
 *
 * The #UDisksPhysicalVolumeSkeleton structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.0.0
 */

/**
 * UDisksPhysicalVolumeSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksPhysicalVolumeSkeleton.
 *
 * Since: 2.0.0
 */

struct _UDisksPhysicalVolumeSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_physical_volume_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksPhysicalVolumeSkeleton *skeleton = UDISKS_PHYSICAL_VOLUME_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_PHYSICAL_VOLUME);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_PHYSICAL_VOLUME);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_physical_volume_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksPhysicalVolumeSkeleton *skeleton = UDISKS_PHYSICAL_VOLUME_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_physical_volume_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_physical_volume_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksPhysicalVolumeSkeleton *skeleton = UDISKS_PHYSICAL_VOLUME_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_physical_volume_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_physical_volume_skeleton_vtable =
{
  _udisks_physical_volume_skeleton_handle_method_call,
  _udisks_physical_volume_skeleton_handle_get_property,
  _udisks_physical_volume_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_physical_volume_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_physical_volume_interface_info ();
}

static GDBusInterfaceVTable *
udisks_physical_volume_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_physical_volume_skeleton_vtable;
}

static GVariant *
udisks_physical_volume_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksPhysicalVolumeSkeleton *skeleton = UDISKS_PHYSICAL_VOLUME_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_physical_volume_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_physical_volume_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_physical_volume_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_physical_volume_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.PhysicalVolume", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_physical_volume_emit_changed (gpointer user_data);

static void
udisks_physical_volume_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksPhysicalVolumeSkeleton *skeleton = UDISKS_PHYSICAL_VOLUME_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_physical_volume_emit_changed (skeleton);
}

static void udisks_physical_volume_skeleton_iface_init (UDisksPhysicalVolumeIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksPhysicalVolumeSkeleton, udisks_physical_volume_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksPhysicalVolumeSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_PHYSICAL_VOLUME, udisks_physical_volume_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksPhysicalVolumeSkeleton, udisks_physical_volume_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_PHYSICAL_VOLUME, udisks_physical_volume_skeleton_iface_init))

#endif
static void
udisks_physical_volume_skeleton_finalize (GObject *object)
{
  UDisksPhysicalVolumeSkeleton *skeleton = UDISKS_PHYSICAL_VOLUME_SKELETON (object);
  guint n;
  for (n = 0; n < 3; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_physical_volume_skeleton_parent_class)->finalize (object);
}

static void
udisks_physical_volume_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksPhysicalVolumeSkeleton *skeleton = UDISKS_PHYSICAL_VOLUME_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 3);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_physical_volume_emit_changed (gpointer user_data)
{
  UDisksPhysicalVolumeSkeleton *skeleton = UDISKS_PHYSICAL_VOLUME_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.PhysicalVolume",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_physical_volume_schedule_emit_changed (UDisksPhysicalVolumeSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_physical_volume_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksPhysicalVolumeSkeleton *skeleton = UDISKS_PHYSICAL_VOLUME_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_physical_volume_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_physical_volume_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_physical_volume_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksPhysicalVolumeSkeleton *skeleton = UDISKS_PHYSICAL_VOLUME_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 3);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_physical_volume_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_physical_volume_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_physical_volume_skeleton_init (UDisksPhysicalVolumeSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_physical_volume_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_PHYSICAL_VOLUME_SKELETON, UDisksPhysicalVolumeSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 3);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_UINT64);
}

static const gchar *
udisks_physical_volume_skeleton_get_volume_group (UDisksPhysicalVolume *object)
{
  UDisksPhysicalVolumeSkeleton *skeleton = UDISKS_PHYSICAL_VOLUME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_physical_volume_skeleton_get_size (UDisksPhysicalVolume *object)
{
  UDisksPhysicalVolumeSkeleton *skeleton = UDISKS_PHYSICAL_VOLUME_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_physical_volume_skeleton_get_free_size (UDisksPhysicalVolume *object)
{
  UDisksPhysicalVolumeSkeleton *skeleton = UDISKS_PHYSICAL_VOLUME_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_physical_volume_skeleton_class_init (UDisksPhysicalVolumeSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_physical_volume_skeleton_finalize;
  gobject_class->get_property = udisks_physical_volume_skeleton_get_property;
  gobject_class->set_property = udisks_physical_volume_skeleton_set_property;
  gobject_class->notify       = udisks_physical_volume_skeleton_notify;


  udisks_physical_volume_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_physical_volume_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_physical_volume_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_physical_volume_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_physical_volume_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksPhysicalVolumeSkeletonPrivate));
#endif
}

static void
udisks_physical_volume_skeleton_iface_init (UDisksPhysicalVolumeIface *iface)
{
  iface->get_volume_group = udisks_physical_volume_skeleton_get_volume_group;
  iface->get_size = udisks_physical_volume_skeleton_get_size;
  iface->get_free_size = udisks_physical_volume_skeleton_get_free_size;
}

/**
 * udisks_physical_volume_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PhysicalVolume.top_of_page">org.freedesktop.UDisks2.PhysicalVolume</link>.
 *
 * Returns: (transfer full) (type UDisksPhysicalVolumeSkeleton): The skeleton object.
 *
 * Since: 2.0.0
 */
UDisksPhysicalVolume *
udisks_physical_volume_skeleton_new (void)
{
  return UDISKS_PHYSICAL_VOLUME (g_object_new (UDISKS_TYPE_PHYSICAL_VOLUME_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.VolumeGroup
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksVolumeGroup
 * @title: UDisksVolumeGroup
 * @short_description: Generated C code for the org.freedesktop.UDisks2.VolumeGroup D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-VolumeGroup.top_of_page">org.freedesktop.UDisks2.VolumeGroup</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.VolumeGroup ---- */

static const _ExtendedGDBusMethodInfo _udisks_volume_group_method_info_poll =
{
  {
    -1,
    (gchar *) "Poll",
    NULL,
    NULL,
    NULL
  },
  "handle-poll",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_delete_IN_ARG_wipe =
{
  {
    -1,
    (gchar *) "wipe",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_delete_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_delete_IN_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_delete_IN_ARG_wipe.parent_struct,
  &_udisks_volume_group_method_info_delete_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_volume_group_method_info_delete =
{
  {
    -1,
    (gchar *) "Delete",
    (GDBusArgInfo **) &_udisks_volume_group_method_info_delete_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-delete",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_rename_IN_ARG_new_name =
{
  {
    -1,
    (gchar *) "new_name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_rename_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_rename_IN_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_rename_IN_ARG_new_name.parent_struct,
  &_udisks_volume_group_method_info_rename_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_rename_OUT_ARG_result =
{
  {
    -1,
    (gchar *) "result",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_rename_OUT_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_rename_OUT_ARG_result.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_volume_group_method_info_rename =
{
  {
    -1,
    (gchar *) "Rename",
    (GDBusArgInfo **) &_udisks_volume_group_method_info_rename_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_volume_group_method_info_rename_OUT_ARG_pointers,
    NULL
  },
  "handle-rename",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_add_device_IN_ARG_block =
{
  {
    -1,
    (gchar *) "block",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_add_device_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_add_device_IN_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_add_device_IN_ARG_block.parent_struct,
  &_udisks_volume_group_method_info_add_device_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_volume_group_method_info_add_device =
{
  {
    -1,
    (gchar *) "AddDevice",
    (GDBusArgInfo **) &_udisks_volume_group_method_info_add_device_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-add-device",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_empty_device_IN_ARG_block =
{
  {
    -1,
    (gchar *) "block",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_empty_device_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_empty_device_IN_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_empty_device_IN_ARG_block.parent_struct,
  &_udisks_volume_group_method_info_empty_device_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_volume_group_method_info_empty_device =
{
  {
    -1,
    (gchar *) "EmptyDevice",
    (GDBusArgInfo **) &_udisks_volume_group_method_info_empty_device_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-empty-device",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_remove_device_IN_ARG_block =
{
  {
    -1,
    (gchar *) "block",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_remove_device_IN_ARG_wipe =
{
  {
    -1,
    (gchar *) "wipe",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_remove_device_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_remove_device_IN_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_remove_device_IN_ARG_block.parent_struct,
  &_udisks_volume_group_method_info_remove_device_IN_ARG_wipe.parent_struct,
  &_udisks_volume_group_method_info_remove_device_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_volume_group_method_info_remove_device =
{
  {
    -1,
    (gchar *) "RemoveDevice",
    (GDBusArgInfo **) &_udisks_volume_group_method_info_remove_device_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-remove-device",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_remove_missing_physical_volumes_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_remove_missing_physical_volumes_IN_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_remove_missing_physical_volumes_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_volume_group_method_info_remove_missing_physical_volumes =
{
  {
    -1,
    (gchar *) "RemoveMissingPhysicalVolumes",
    (GDBusArgInfo **) &_udisks_volume_group_method_info_remove_missing_physical_volumes_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-remove-missing-physical-volumes",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_plain_volume_IN_ARG_name =
{
  {
    -1,
    (gchar *) "name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_plain_volume_IN_ARG_size =
{
  {
    -1,
    (gchar *) "size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_plain_volume_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_create_plain_volume_IN_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_create_plain_volume_IN_ARG_name.parent_struct,
  &_udisks_volume_group_method_info_create_plain_volume_IN_ARG_size.parent_struct,
  &_udisks_volume_group_method_info_create_plain_volume_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_plain_volume_OUT_ARG_result =
{
  {
    -1,
    (gchar *) "result",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_create_plain_volume_OUT_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_create_plain_volume_OUT_ARG_result.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_volume_group_method_info_create_plain_volume =
{
  {
    -1,
    (gchar *) "CreatePlainVolume",
    (GDBusArgInfo **) &_udisks_volume_group_method_info_create_plain_volume_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_volume_group_method_info_create_plain_volume_OUT_ARG_pointers,
    NULL
  },
  "handle-create-plain-volume",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_plain_volume_with_layout_IN_ARG_name =
{
  {
    -1,
    (gchar *) "name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_plain_volume_with_layout_IN_ARG_size =
{
  {
    -1,
    (gchar *) "size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_plain_volume_with_layout_IN_ARG_layout =
{
  {
    -1,
    (gchar *) "layout",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_plain_volume_with_layout_IN_ARG_pvs =
{
  {
    -1,
    (gchar *) "pvs",
    (gchar *) "ao",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_plain_volume_with_layout_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_create_plain_volume_with_layout_IN_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_create_plain_volume_with_layout_IN_ARG_name.parent_struct,
  &_udisks_volume_group_method_info_create_plain_volume_with_layout_IN_ARG_size.parent_struct,
  &_udisks_volume_group_method_info_create_plain_volume_with_layout_IN_ARG_layout.parent_struct,
  &_udisks_volume_group_method_info_create_plain_volume_with_layout_IN_ARG_pvs.parent_struct,
  &_udisks_volume_group_method_info_create_plain_volume_with_layout_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_plain_volume_with_layout_OUT_ARG_result =
{
  {
    -1,
    (gchar *) "result",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_create_plain_volume_with_layout_OUT_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_create_plain_volume_with_layout_OUT_ARG_result.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_volume_group_method_info_create_plain_volume_with_layout =
{
  {
    -1,
    (gchar *) "CreatePlainVolumeWithLayout",
    (GDBusArgInfo **) &_udisks_volume_group_method_info_create_plain_volume_with_layout_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_volume_group_method_info_create_plain_volume_with_layout_OUT_ARG_pointers,
    NULL
  },
  "handle-create-plain-volume-with-layout",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_thin_pool_volume_IN_ARG_name =
{
  {
    -1,
    (gchar *) "name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_thin_pool_volume_IN_ARG_size =
{
  {
    -1,
    (gchar *) "size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_thin_pool_volume_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_create_thin_pool_volume_IN_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_create_thin_pool_volume_IN_ARG_name.parent_struct,
  &_udisks_volume_group_method_info_create_thin_pool_volume_IN_ARG_size.parent_struct,
  &_udisks_volume_group_method_info_create_thin_pool_volume_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_thin_pool_volume_OUT_ARG_result =
{
  {
    -1,
    (gchar *) "result",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_create_thin_pool_volume_OUT_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_create_thin_pool_volume_OUT_ARG_result.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_volume_group_method_info_create_thin_pool_volume =
{
  {
    -1,
    (gchar *) "CreateThinPoolVolume",
    (GDBusArgInfo **) &_udisks_volume_group_method_info_create_thin_pool_volume_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_volume_group_method_info_create_thin_pool_volume_OUT_ARG_pointers,
    NULL
  },
  "handle-create-thin-pool-volume",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_thin_volume_IN_ARG_name =
{
  {
    -1,
    (gchar *) "name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_thin_volume_IN_ARG_size =
{
  {
    -1,
    (gchar *) "size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_thin_volume_IN_ARG_pool =
{
  {
    -1,
    (gchar *) "pool",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_thin_volume_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_create_thin_volume_IN_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_create_thin_volume_IN_ARG_name.parent_struct,
  &_udisks_volume_group_method_info_create_thin_volume_IN_ARG_size.parent_struct,
  &_udisks_volume_group_method_info_create_thin_volume_IN_ARG_pool.parent_struct,
  &_udisks_volume_group_method_info_create_thin_volume_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_thin_volume_OUT_ARG_result =
{
  {
    -1,
    (gchar *) "result",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_create_thin_volume_OUT_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_create_thin_volume_OUT_ARG_result.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_volume_group_method_info_create_thin_volume =
{
  {
    -1,
    (gchar *) "CreateThinVolume",
    (GDBusArgInfo **) &_udisks_volume_group_method_info_create_thin_volume_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_volume_group_method_info_create_thin_volume_OUT_ARG_pointers,
    NULL
  },
  "handle-create-thin-volume",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_vdo_volume_IN_ARG_lv_name =
{
  {
    -1,
    (gchar *) "lv_name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_vdo_volume_IN_ARG_pool_name =
{
  {
    -1,
    (gchar *) "pool_name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_vdo_volume_IN_ARG_data_size =
{
  {
    -1,
    (gchar *) "data_size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_vdo_volume_IN_ARG_virtual_size =
{
  {
    -1,
    (gchar *) "virtual_size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_vdo_volume_IN_ARG_index_memory =
{
  {
    -1,
    (gchar *) "index_memory",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_vdo_volume_IN_ARG_compression =
{
  {
    -1,
    (gchar *) "compression",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_vdo_volume_IN_ARG_deduplication =
{
  {
    -1,
    (gchar *) "deduplication",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_vdo_volume_IN_ARG_write_policy =
{
  {
    -1,
    (gchar *) "write_policy",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_vdo_volume_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_create_vdo_volume_IN_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_create_vdo_volume_IN_ARG_lv_name.parent_struct,
  &_udisks_volume_group_method_info_create_vdo_volume_IN_ARG_pool_name.parent_struct,
  &_udisks_volume_group_method_info_create_vdo_volume_IN_ARG_data_size.parent_struct,
  &_udisks_volume_group_method_info_create_vdo_volume_IN_ARG_virtual_size.parent_struct,
  &_udisks_volume_group_method_info_create_vdo_volume_IN_ARG_index_memory.parent_struct,
  &_udisks_volume_group_method_info_create_vdo_volume_IN_ARG_compression.parent_struct,
  &_udisks_volume_group_method_info_create_vdo_volume_IN_ARG_deduplication.parent_struct,
  &_udisks_volume_group_method_info_create_vdo_volume_IN_ARG_write_policy.parent_struct,
  &_udisks_volume_group_method_info_create_vdo_volume_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_volume_group_method_info_create_vdo_volume_OUT_ARG_result =
{
  {
    -1,
    (gchar *) "result",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_volume_group_method_info_create_vdo_volume_OUT_ARG_pointers[] =
{
  &_udisks_volume_group_method_info_create_vdo_volume_OUT_ARG_result.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_volume_group_method_info_create_vdo_volume =
{
  {
    -1,
    (gchar *) "CreateVDOVolume",
    (GDBusArgInfo **) &_udisks_volume_group_method_info_create_vdo_volume_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_volume_group_method_info_create_vdo_volume_OUT_ARG_pointers,
    NULL
  },
  "handle-create-vdo-volume",
  FALSE
};

static const GDBusMethodInfo * const _udisks_volume_group_method_info_pointers[] =
{
  &_udisks_volume_group_method_info_poll.parent_struct,
  &_udisks_volume_group_method_info_delete.parent_struct,
  &_udisks_volume_group_method_info_rename.parent_struct,
  &_udisks_volume_group_method_info_add_device.parent_struct,
  &_udisks_volume_group_method_info_empty_device.parent_struct,
  &_udisks_volume_group_method_info_remove_device.parent_struct,
  &_udisks_volume_group_method_info_remove_missing_physical_volumes.parent_struct,
  &_udisks_volume_group_method_info_create_plain_volume.parent_struct,
  &_udisks_volume_group_method_info_create_plain_volume_with_layout.parent_struct,
  &_udisks_volume_group_method_info_create_thin_pool_volume.parent_struct,
  &_udisks_volume_group_method_info_create_thin_volume.parent_struct,
  &_udisks_volume_group_method_info_create_vdo_volume.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_volume_group_property_info_name =
{
  {
    -1,
    (gchar *) "Name",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "name",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_volume_group_property_info_uuid =
{
  {
    -1,
    (gchar *) "UUID",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "uuid",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_volume_group_property_info_size =
{
  {
    -1,
    (gchar *) "Size",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "size",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_volume_group_property_info_free_size =
{
  {
    -1,
    (gchar *) "FreeSize",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "free-size",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_volume_group_property_info_extent_size =
{
  {
    -1,
    (gchar *) "ExtentSize",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "extent-size",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_volume_group_property_info_needs_polling =
{
  {
    -1,
    (gchar *) "NeedsPolling",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "needs-polling",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_volume_group_property_info_missing_physical_volumes =
{
  {
    -1,
    (gchar *) "MissingPhysicalVolumes",
    (gchar *) "as",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "missing-physical-volumes",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_volume_group_property_info_pointers[] =
{
  &_udisks_volume_group_property_info_name.parent_struct,
  &_udisks_volume_group_property_info_uuid.parent_struct,
  &_udisks_volume_group_property_info_size.parent_struct,
  &_udisks_volume_group_property_info_free_size.parent_struct,
  &_udisks_volume_group_property_info_extent_size.parent_struct,
  &_udisks_volume_group_property_info_needs_polling.parent_struct,
  &_udisks_volume_group_property_info_missing_physical_volumes.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_volume_group_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.VolumeGroup",
    (GDBusMethodInfo **) &_udisks_volume_group_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_volume_group_property_info_pointers,
    NULL
  },
  "volume-group",
};


/**
 * udisks_volume_group_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-VolumeGroup.top_of_page">org.freedesktop.UDisks2.VolumeGroup</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 *
 * Since: 2.0.0
 */
GDBusInterfaceInfo *
udisks_volume_group_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_volume_group_interface_info.parent_struct;
}

/**
 * udisks_volume_group_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksVolumeGroup interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 *
 * Since: 2.0.0
 */
guint
udisks_volume_group_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "name");
  g_object_class_override_property (klass, property_id_begin++, "uuid");
  g_object_class_override_property (klass, property_id_begin++, "size");
  g_object_class_override_property (klass, property_id_begin++, "free-size");
  g_object_class_override_property (klass, property_id_begin++, "extent-size");
  g_object_class_override_property (klass, property_id_begin++, "needs-polling");
  g_object_class_override_property (klass, property_id_begin++, "missing-physical-volumes");
  return property_id_begin - 1;
}


inline static void
udisks_volume_group_method_marshal_poll (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_volume_group_method_marshal_delete (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOOLEAN_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_volume_group_method_marshal_rename (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_volume_group_method_marshal_add_device (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_volume_group_method_marshal_empty_device (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_volume_group_method_marshal_remove_device (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_BOOLEAN_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_volume_group_method_marshal_remove_missing_physical_volumes (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_volume_group_method_marshal_create_plain_volume (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_UINT64_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_volume_group_method_marshal_create_plain_volume_with_layout (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_UINT64_STRING_BOXED_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_volume_group_method_marshal_create_thin_pool_volume (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_UINT64_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_volume_group_method_marshal_create_thin_volume (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_UINT64_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_volume_group_method_marshal_create_vdo_volume (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_STRING_UINT64_UINT64_UINT64_BOOLEAN_BOOLEAN_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksVolumeGroup:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VolumeGroup.top_of_page">org.freedesktop.UDisks2.VolumeGroup</link>.
 *
 * Since: 2.0.0
 */

/**
 * UDisksVolumeGroupIface:
 * @parent_iface: The parent interface.
 * @handle_add_device: Handler for the #UDisksVolumeGroup::handle-add-device signal.
 * @handle_create_plain_volume: Handler for the #UDisksVolumeGroup::handle-create-plain-volume signal.
 * @handle_create_plain_volume_with_layout: Handler for the #UDisksVolumeGroup::handle-create-plain-volume-with-layout signal.
 * @handle_create_thin_pool_volume: Handler for the #UDisksVolumeGroup::handle-create-thin-pool-volume signal.
 * @handle_create_thin_volume: Handler for the #UDisksVolumeGroup::handle-create-thin-volume signal.
 * @handle_create_vdo_volume: Handler for the #UDisksVolumeGroup::handle-create-vdo-volume signal.
 * @handle_delete: Handler for the #UDisksVolumeGroup::handle-delete signal.
 * @handle_empty_device: Handler for the #UDisksVolumeGroup::handle-empty-device signal.
 * @handle_poll: Handler for the #UDisksVolumeGroup::handle-poll signal.
 * @handle_remove_device: Handler for the #UDisksVolumeGroup::handle-remove-device signal.
 * @handle_remove_missing_physical_volumes: Handler for the #UDisksVolumeGroup::handle-remove-missing-physical-volumes signal.
 * @handle_rename: Handler for the #UDisksVolumeGroup::handle-rename signal.
 * @get_extent_size: Getter for the #UDisksVolumeGroup:extent-size property.
 * @get_free_size: Getter for the #UDisksVolumeGroup:free-size property.
 * @get_missing_physical_volumes: Getter for the #UDisksVolumeGroup:missing-physical-volumes property.
 * @get_name: Getter for the #UDisksVolumeGroup:name property.
 * @get_needs_polling: Getter for the #UDisksVolumeGroup:needs-polling property.
 * @get_size: Getter for the #UDisksVolumeGroup:size property.
 * @get_uuid: Getter for the #UDisksVolumeGroup:uuid property.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VolumeGroup.top_of_page">org.freedesktop.UDisks2.VolumeGroup</link>.
 *
 * Since: 2.0.0
 */

typedef UDisksVolumeGroupIface UDisksVolumeGroupInterface;
G_DEFINE_INTERFACE (UDisksVolumeGroup, udisks_volume_group, G_TYPE_OBJECT)

static void
udisks_volume_group_default_init (UDisksVolumeGroupIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksVolumeGroup::handle-poll:
   * @object: A #UDisksVolumeGroup.
   * @invocation: A #GDBusMethodInvocation.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.Poll">Poll()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_volume_group_complete_poll() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-poll",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVolumeGroupIface, handle_poll),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_volume_group_method_marshal_poll,
    G_TYPE_BOOLEAN,
    1,
    G_TYPE_DBUS_METHOD_INVOCATION);

  /**
   * UDisksVolumeGroup::handle-delete:
   * @object: A #UDisksVolumeGroup.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_wipe: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.Delete">Delete()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_volume_group_complete_delete() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-delete",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVolumeGroupIface, handle_delete),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_volume_group_method_marshal_delete,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_BOOLEAN, G_TYPE_VARIANT);

  /**
   * UDisksVolumeGroup::handle-rename:
   * @object: A #UDisksVolumeGroup.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_new_name: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.Rename">Rename()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_volume_group_complete_rename() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-rename",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVolumeGroupIface, handle_rename),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_volume_group_method_marshal_rename,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksVolumeGroup::handle-add-device:
   * @object: A #UDisksVolumeGroup.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_block: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.AddDevice">AddDevice()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_volume_group_complete_add_device() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-add-device",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVolumeGroupIface, handle_add_device),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_volume_group_method_marshal_add_device,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksVolumeGroup::handle-empty-device:
   * @object: A #UDisksVolumeGroup.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_block: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.EmptyDevice">EmptyDevice()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_volume_group_complete_empty_device() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-empty-device",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVolumeGroupIface, handle_empty_device),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_volume_group_method_marshal_empty_device,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksVolumeGroup::handle-remove-device:
   * @object: A #UDisksVolumeGroup.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_block: Argument passed by remote caller.
   * @arg_wipe: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.RemoveDevice">RemoveDevice()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_volume_group_complete_remove_device() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-remove-device",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVolumeGroupIface, handle_remove_device),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_volume_group_method_marshal_remove_device,
    G_TYPE_BOOLEAN,
    4,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_VARIANT);

  /**
   * UDisksVolumeGroup::handle-remove-missing-physical-volumes:
   * @object: A #UDisksVolumeGroup.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.RemoveMissingPhysicalVolumes">RemoveMissingPhysicalVolumes()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_volume_group_complete_remove_missing_physical_volumes() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-remove-missing-physical-volumes",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVolumeGroupIface, handle_remove_missing_physical_volumes),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_volume_group_method_marshal_remove_missing_physical_volumes,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksVolumeGroup::handle-create-plain-volume:
   * @object: A #UDisksVolumeGroup.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_name: Argument passed by remote caller.
   * @arg_size: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreatePlainVolume">CreatePlainVolume()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_volume_group_complete_create_plain_volume() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-create-plain-volume",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVolumeGroupIface, handle_create_plain_volume),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_volume_group_method_marshal_create_plain_volume,
    G_TYPE_BOOLEAN,
    4,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_VARIANT);

  /**
   * UDisksVolumeGroup::handle-create-plain-volume-with-layout:
   * @object: A #UDisksVolumeGroup.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_name: Argument passed by remote caller.
   * @arg_size: Argument passed by remote caller.
   * @arg_layout: Argument passed by remote caller.
   * @arg_pvs: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreatePlainVolumeWithLayout">CreatePlainVolumeWithLayout()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_volume_group_complete_create_plain_volume_with_layout() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-create-plain-volume-with-layout",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVolumeGroupIface, handle_create_plain_volume_with_layout),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_volume_group_method_marshal_create_plain_volume_with_layout,
    G_TYPE_BOOLEAN,
    6,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_STRING, G_TYPE_STRV, G_TYPE_VARIANT);

  /**
   * UDisksVolumeGroup::handle-create-thin-pool-volume:
   * @object: A #UDisksVolumeGroup.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_name: Argument passed by remote caller.
   * @arg_size: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreateThinPoolVolume">CreateThinPoolVolume()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_volume_group_complete_create_thin_pool_volume() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-create-thin-pool-volume",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVolumeGroupIface, handle_create_thin_pool_volume),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_volume_group_method_marshal_create_thin_pool_volume,
    G_TYPE_BOOLEAN,
    4,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_VARIANT);

  /**
   * UDisksVolumeGroup::handle-create-thin-volume:
   * @object: A #UDisksVolumeGroup.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_name: Argument passed by remote caller.
   * @arg_size: Argument passed by remote caller.
   * @arg_pool: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreateThinVolume">CreateThinVolume()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_volume_group_complete_create_thin_volume() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-create-thin-volume",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVolumeGroupIface, handle_create_thin_volume),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_volume_group_method_marshal_create_thin_volume,
    G_TYPE_BOOLEAN,
    5,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksVolumeGroup::handle-create-vdo-volume:
   * @object: A #UDisksVolumeGroup.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_lv_name: Argument passed by remote caller.
   * @arg_pool_name: Argument passed by remote caller.
   * @arg_data_size: Argument passed by remote caller.
   * @arg_virtual_size: Argument passed by remote caller.
   * @arg_index_memory: Argument passed by remote caller.
   * @arg_compression: Argument passed by remote caller.
   * @arg_deduplication: Argument passed by remote caller.
   * @arg_write_policy: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreateVDOVolume">CreateVDOVolume()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_volume_group_complete_create_vdo_volume() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-create-vdo-volume",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVolumeGroupIface, handle_create_vdo_volume),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_volume_group_method_marshal_create_vdo_volume,
    G_TYPE_BOOLEAN,
    10,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_UINT64, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksVolumeGroup:name:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.Name">"Name"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("name", "Name", "Name", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksVolumeGroup:uuid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.UUID">"UUID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("uuid", "UUID", "UUID", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksVolumeGroup:size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.Size">"Size"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("size", "Size", "Size", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksVolumeGroup:free-size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.FreeSize">"FreeSize"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("free-size", "FreeSize", "FreeSize", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksVolumeGroup:extent-size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.ExtentSize">"ExtentSize"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("extent-size", "ExtentSize", "ExtentSize", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksVolumeGroup:needs-polling:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.NeedsPolling">"NeedsPolling"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("needs-polling", "NeedsPolling", "NeedsPolling", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksVolumeGroup:missing-physical-volumes:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.MissingPhysicalVolumes">"MissingPhysicalVolumes"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_boxed ("missing-physical-volumes", "MissingPhysicalVolumes", "MissingPhysicalVolumes", G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_volume_group_get_name: (skip)
 * @object: A #UDisksVolumeGroup.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.Name">"Name"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_volume_group_dup_name() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_volume_group_get_name (UDisksVolumeGroup *object)
{
  g_return_val_if_fail (UDISKS_IS_VOLUME_GROUP (object), NULL);

  return UDISKS_VOLUME_GROUP_GET_IFACE (object)->get_name (object);
}

/**
 * udisks_volume_group_dup_name: (skip)
 * @object: A #UDisksVolumeGroup.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.Name">"Name"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_volume_group_dup_name (UDisksVolumeGroup *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "name", &value, NULL);
  return value;
}

/**
 * udisks_volume_group_set_name: (skip)
 * @object: A #UDisksVolumeGroup.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.Name">"Name"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_set_name (UDisksVolumeGroup *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "name", value, NULL);
}

/**
 * udisks_volume_group_get_uuid: (skip)
 * @object: A #UDisksVolumeGroup.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.UUID">"UUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_volume_group_dup_uuid() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_volume_group_get_uuid (UDisksVolumeGroup *object)
{
  g_return_val_if_fail (UDISKS_IS_VOLUME_GROUP (object), NULL);

  return UDISKS_VOLUME_GROUP_GET_IFACE (object)->get_uuid (object);
}

/**
 * udisks_volume_group_dup_uuid: (skip)
 * @object: A #UDisksVolumeGroup.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.UUID">"UUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_volume_group_dup_uuid (UDisksVolumeGroup *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "uuid", &value, NULL);
  return value;
}

/**
 * udisks_volume_group_set_uuid: (skip)
 * @object: A #UDisksVolumeGroup.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.UUID">"UUID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_set_uuid (UDisksVolumeGroup *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "uuid", value, NULL);
}

/**
 * udisks_volume_group_get_size: (skip)
 * @object: A #UDisksVolumeGroup.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.Size">"Size"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
guint64 
udisks_volume_group_get_size (UDisksVolumeGroup *object)
{
  g_return_val_if_fail (UDISKS_IS_VOLUME_GROUP (object), 0);

  return UDISKS_VOLUME_GROUP_GET_IFACE (object)->get_size (object);
}

/**
 * udisks_volume_group_set_size: (skip)
 * @object: A #UDisksVolumeGroup.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.Size">"Size"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_set_size (UDisksVolumeGroup *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "size", value, NULL);
}

/**
 * udisks_volume_group_get_free_size: (skip)
 * @object: A #UDisksVolumeGroup.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.FreeSize">"FreeSize"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
guint64 
udisks_volume_group_get_free_size (UDisksVolumeGroup *object)
{
  g_return_val_if_fail (UDISKS_IS_VOLUME_GROUP (object), 0);

  return UDISKS_VOLUME_GROUP_GET_IFACE (object)->get_free_size (object);
}

/**
 * udisks_volume_group_set_free_size: (skip)
 * @object: A #UDisksVolumeGroup.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.FreeSize">"FreeSize"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_set_free_size (UDisksVolumeGroup *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "free-size", value, NULL);
}

/**
 * udisks_volume_group_get_extent_size: (skip)
 * @object: A #UDisksVolumeGroup.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.ExtentSize">"ExtentSize"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
guint64 
udisks_volume_group_get_extent_size (UDisksVolumeGroup *object)
{
  g_return_val_if_fail (UDISKS_IS_VOLUME_GROUP (object), 0);

  return UDISKS_VOLUME_GROUP_GET_IFACE (object)->get_extent_size (object);
}

/**
 * udisks_volume_group_set_extent_size: (skip)
 * @object: A #UDisksVolumeGroup.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.ExtentSize">"ExtentSize"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_set_extent_size (UDisksVolumeGroup *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "extent-size", value, NULL);
}

/**
 * udisks_volume_group_get_needs_polling: (skip)
 * @object: A #UDisksVolumeGroup.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.NeedsPolling">"NeedsPolling"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
gboolean 
udisks_volume_group_get_needs_polling (UDisksVolumeGroup *object)
{
  g_return_val_if_fail (UDISKS_IS_VOLUME_GROUP (object), FALSE);

  return UDISKS_VOLUME_GROUP_GET_IFACE (object)->get_needs_polling (object);
}

/**
 * udisks_volume_group_set_needs_polling: (skip)
 * @object: A #UDisksVolumeGroup.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.NeedsPolling">"NeedsPolling"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_set_needs_polling (UDisksVolumeGroup *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "needs-polling", value, NULL);
}

/**
 * udisks_volume_group_get_missing_physical_volumes: (skip)
 * @object: A #UDisksVolumeGroup.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.MissingPhysicalVolumes">"MissingPhysicalVolumes"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_volume_group_dup_missing_physical_volumes() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *const *
udisks_volume_group_get_missing_physical_volumes (UDisksVolumeGroup *object)
{
  g_return_val_if_fail (UDISKS_IS_VOLUME_GROUP (object), NULL);

  return UDISKS_VOLUME_GROUP_GET_IFACE (object)->get_missing_physical_volumes (object);
}

/**
 * udisks_volume_group_dup_missing_physical_volumes: (skip)
 * @object: A #UDisksVolumeGroup.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.MissingPhysicalVolumes">"MissingPhysicalVolumes"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_strfreev().
 *
 * Since: 2.0.0
 */
gchar **
udisks_volume_group_dup_missing_physical_volumes (UDisksVolumeGroup *object)
{
  gchar **value;
  g_object_get (G_OBJECT (object), "missing-physical-volumes", &value, NULL);
  return value;
}

/**
 * udisks_volume_group_set_missing_physical_volumes: (skip)
 * @object: A #UDisksVolumeGroup.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VolumeGroup.MissingPhysicalVolumes">"MissingPhysicalVolumes"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_set_missing_physical_volumes (UDisksVolumeGroup *object, const gchar *const *value)
{
  g_object_set (G_OBJECT (object), "missing-physical-volumes", value, NULL);
}

/**
 * udisks_volume_group_call_poll:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.Poll">Poll()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_call_poll_finish() to get the result of the operation.
 *
 * See udisks_volume_group_call_poll_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_call_poll (
    UDisksVolumeGroup *proxy,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Poll",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_volume_group_call_poll_finish:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_call_poll().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_volume_group_call_poll().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_poll_finish (
    UDisksVolumeGroup *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_poll_sync:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.Poll">Poll()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_call_poll() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_poll_sync (
    UDisksVolumeGroup *proxy,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Poll",
    g_variant_new ("()"),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_delete:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_wipe: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.Delete">Delete()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_call_delete_finish() to get the result of the operation.
 *
 * See udisks_volume_group_call_delete_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_call_delete (
    UDisksVolumeGroup *proxy,
    gboolean arg_wipe,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Delete",
    g_variant_new ("(b@a{sv})",
                   arg_wipe,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_volume_group_call_delete_finish:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_call_delete().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_volume_group_call_delete().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_delete_finish (
    UDisksVolumeGroup *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_delete_sync:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_wipe: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.Delete">Delete()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_call_delete() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_delete_sync (
    UDisksVolumeGroup *proxy,
    gboolean arg_wipe,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Delete",
    g_variant_new ("(b@a{sv})",
                   arg_wipe,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_rename:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_new_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.Rename">Rename()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_call_rename_finish() to get the result of the operation.
 *
 * See udisks_volume_group_call_rename_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_call_rename (
    UDisksVolumeGroup *proxy,
    const gchar *arg_new_name,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Rename",
    g_variant_new ("(s@a{sv})",
                   arg_new_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_volume_group_call_rename_finish:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_call_rename().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_volume_group_call_rename().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_rename_finish (
    UDisksVolumeGroup *proxy,
    gchar ** out_result,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_rename_sync:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_new_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.Rename">Rename()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_call_rename() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_rename_sync (
    UDisksVolumeGroup *proxy,
    const gchar *arg_new_name,
    GVariant *arg_options,
    gchar ** out_result,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Rename",
    g_variant_new ("(s@a{sv})",
                   arg_new_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_add_device:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_block: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.AddDevice">AddDevice()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_call_add_device_finish() to get the result of the operation.
 *
 * See udisks_volume_group_call_add_device_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_call_add_device (
    UDisksVolumeGroup *proxy,
    const gchar *arg_block,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "AddDevice",
    g_variant_new ("(o@a{sv})",
                   arg_block,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_volume_group_call_add_device_finish:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_call_add_device().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_volume_group_call_add_device().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_add_device_finish (
    UDisksVolumeGroup *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_add_device_sync:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_block: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.AddDevice">AddDevice()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_call_add_device() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_add_device_sync (
    UDisksVolumeGroup *proxy,
    const gchar *arg_block,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "AddDevice",
    g_variant_new ("(o@a{sv})",
                   arg_block,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_empty_device:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_block: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.EmptyDevice">EmptyDevice()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_call_empty_device_finish() to get the result of the operation.
 *
 * See udisks_volume_group_call_empty_device_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_call_empty_device (
    UDisksVolumeGroup *proxy,
    const gchar *arg_block,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "EmptyDevice",
    g_variant_new ("(o@a{sv})",
                   arg_block,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_volume_group_call_empty_device_finish:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_call_empty_device().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_volume_group_call_empty_device().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_empty_device_finish (
    UDisksVolumeGroup *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_empty_device_sync:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_block: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.EmptyDevice">EmptyDevice()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_call_empty_device() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_empty_device_sync (
    UDisksVolumeGroup *proxy,
    const gchar *arg_block,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "EmptyDevice",
    g_variant_new ("(o@a{sv})",
                   arg_block,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_remove_device:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_block: Argument to pass with the method invocation.
 * @arg_wipe: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.RemoveDevice">RemoveDevice()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_call_remove_device_finish() to get the result of the operation.
 *
 * See udisks_volume_group_call_remove_device_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_call_remove_device (
    UDisksVolumeGroup *proxy,
    const gchar *arg_block,
    gboolean arg_wipe,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "RemoveDevice",
    g_variant_new ("(ob@a{sv})",
                   arg_block,
                   arg_wipe,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_volume_group_call_remove_device_finish:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_call_remove_device().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_volume_group_call_remove_device().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_remove_device_finish (
    UDisksVolumeGroup *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_remove_device_sync:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_block: Argument to pass with the method invocation.
 * @arg_wipe: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.RemoveDevice">RemoveDevice()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_call_remove_device() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_remove_device_sync (
    UDisksVolumeGroup *proxy,
    const gchar *arg_block,
    gboolean arg_wipe,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "RemoveDevice",
    g_variant_new ("(ob@a{sv})",
                   arg_block,
                   arg_wipe,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_remove_missing_physical_volumes:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.RemoveMissingPhysicalVolumes">RemoveMissingPhysicalVolumes()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_call_remove_missing_physical_volumes_finish() to get the result of the operation.
 *
 * See udisks_volume_group_call_remove_missing_physical_volumes_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_call_remove_missing_physical_volumes (
    UDisksVolumeGroup *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "RemoveMissingPhysicalVolumes",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_volume_group_call_remove_missing_physical_volumes_finish:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_call_remove_missing_physical_volumes().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_volume_group_call_remove_missing_physical_volumes().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_remove_missing_physical_volumes_finish (
    UDisksVolumeGroup *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_remove_missing_physical_volumes_sync:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.RemoveMissingPhysicalVolumes">RemoveMissingPhysicalVolumes()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_call_remove_missing_physical_volumes() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_remove_missing_physical_volumes_sync (
    UDisksVolumeGroup *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "RemoveMissingPhysicalVolumes",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_create_plain_volume:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreatePlainVolume">CreatePlainVolume()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_call_create_plain_volume_finish() to get the result of the operation.
 *
 * See udisks_volume_group_call_create_plain_volume_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_call_create_plain_volume (
    UDisksVolumeGroup *proxy,
    const gchar *arg_name,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CreatePlainVolume",
    g_variant_new ("(st@a{sv})",
                   arg_name,
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_volume_group_call_create_plain_volume_finish:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_call_create_plain_volume().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_volume_group_call_create_plain_volume().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_create_plain_volume_finish (
    UDisksVolumeGroup *proxy,
    gchar ** out_result,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_create_plain_volume_sync:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreatePlainVolume">CreatePlainVolume()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_call_create_plain_volume() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_create_plain_volume_sync (
    UDisksVolumeGroup *proxy,
    const gchar *arg_name,
    guint64 arg_size,
    GVariant *arg_options,
    gchar ** out_result,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CreatePlainVolume",
    g_variant_new ("(st@a{sv})",
                   arg_name,
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_create_plain_volume_with_layout:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_layout: Argument to pass with the method invocation.
 * @arg_pvs: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreatePlainVolumeWithLayout">CreatePlainVolumeWithLayout()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_call_create_plain_volume_with_layout_finish() to get the result of the operation.
 *
 * See udisks_volume_group_call_create_plain_volume_with_layout_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_call_create_plain_volume_with_layout (
    UDisksVolumeGroup *proxy,
    const gchar *arg_name,
    guint64 arg_size,
    const gchar *arg_layout,
    const gchar *const *arg_pvs,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CreatePlainVolumeWithLayout",
    g_variant_new ("(sts^ao@a{sv})",
                   arg_name,
                   arg_size,
                   arg_layout,
                   arg_pvs,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_volume_group_call_create_plain_volume_with_layout_finish:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_call_create_plain_volume_with_layout().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_volume_group_call_create_plain_volume_with_layout().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_create_plain_volume_with_layout_finish (
    UDisksVolumeGroup *proxy,
    gchar ** out_result,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_create_plain_volume_with_layout_sync:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_layout: Argument to pass with the method invocation.
 * @arg_pvs: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreatePlainVolumeWithLayout">CreatePlainVolumeWithLayout()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_call_create_plain_volume_with_layout() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_create_plain_volume_with_layout_sync (
    UDisksVolumeGroup *proxy,
    const gchar *arg_name,
    guint64 arg_size,
    const gchar *arg_layout,
    const gchar *const *arg_pvs,
    GVariant *arg_options,
    gchar ** out_result,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CreatePlainVolumeWithLayout",
    g_variant_new ("(sts^ao@a{sv})",
                   arg_name,
                   arg_size,
                   arg_layout,
                   arg_pvs,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_create_thin_pool_volume:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreateThinPoolVolume">CreateThinPoolVolume()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_call_create_thin_pool_volume_finish() to get the result of the operation.
 *
 * See udisks_volume_group_call_create_thin_pool_volume_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_call_create_thin_pool_volume (
    UDisksVolumeGroup *proxy,
    const gchar *arg_name,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CreateThinPoolVolume",
    g_variant_new ("(st@a{sv})",
                   arg_name,
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_volume_group_call_create_thin_pool_volume_finish:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_call_create_thin_pool_volume().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_volume_group_call_create_thin_pool_volume().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_create_thin_pool_volume_finish (
    UDisksVolumeGroup *proxy,
    gchar ** out_result,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_create_thin_pool_volume_sync:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreateThinPoolVolume">CreateThinPoolVolume()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_call_create_thin_pool_volume() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_create_thin_pool_volume_sync (
    UDisksVolumeGroup *proxy,
    const gchar *arg_name,
    guint64 arg_size,
    GVariant *arg_options,
    gchar ** out_result,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CreateThinPoolVolume",
    g_variant_new ("(st@a{sv})",
                   arg_name,
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_create_thin_volume:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_pool: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreateThinVolume">CreateThinVolume()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_call_create_thin_volume_finish() to get the result of the operation.
 *
 * See udisks_volume_group_call_create_thin_volume_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_call_create_thin_volume (
    UDisksVolumeGroup *proxy,
    const gchar *arg_name,
    guint64 arg_size,
    const gchar *arg_pool,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CreateThinVolume",
    g_variant_new ("(sto@a{sv})",
                   arg_name,
                   arg_size,
                   arg_pool,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_volume_group_call_create_thin_volume_finish:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_call_create_thin_volume().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_volume_group_call_create_thin_volume().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_create_thin_volume_finish (
    UDisksVolumeGroup *proxy,
    gchar ** out_result,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_create_thin_volume_sync:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_pool: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreateThinVolume">CreateThinVolume()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_call_create_thin_volume() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_create_thin_volume_sync (
    UDisksVolumeGroup *proxy,
    const gchar *arg_name,
    guint64 arg_size,
    const gchar *arg_pool,
    GVariant *arg_options,
    gchar ** out_result,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CreateThinVolume",
    g_variant_new ("(sto@a{sv})",
                   arg_name,
                   arg_size,
                   arg_pool,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_create_vdo_volume:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_lv_name: Argument to pass with the method invocation.
 * @arg_pool_name: Argument to pass with the method invocation.
 * @arg_data_size: Argument to pass with the method invocation.
 * @arg_virtual_size: Argument to pass with the method invocation.
 * @arg_index_memory: Argument to pass with the method invocation.
 * @arg_compression: Argument to pass with the method invocation.
 * @arg_deduplication: Argument to pass with the method invocation.
 * @arg_write_policy: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreateVDOVolume">CreateVDOVolume()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_call_create_vdo_volume_finish() to get the result of the operation.
 *
 * See udisks_volume_group_call_create_vdo_volume_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_call_create_vdo_volume (
    UDisksVolumeGroup *proxy,
    const gchar *arg_lv_name,
    const gchar *arg_pool_name,
    guint64 arg_data_size,
    guint64 arg_virtual_size,
    guint64 arg_index_memory,
    gboolean arg_compression,
    gboolean arg_deduplication,
    const gchar *arg_write_policy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CreateVDOVolume",
    g_variant_new ("(sstttbbs@a{sv})",
                   arg_lv_name,
                   arg_pool_name,
                   arg_data_size,
                   arg_virtual_size,
                   arg_index_memory,
                   arg_compression,
                   arg_deduplication,
                   arg_write_policy,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_volume_group_call_create_vdo_volume_finish:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_call_create_vdo_volume().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_volume_group_call_create_vdo_volume().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_create_vdo_volume_finish (
    UDisksVolumeGroup *proxy,
    gchar ** out_result,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_call_create_vdo_volume_sync:
 * @proxy: A #UDisksVolumeGroupProxy.
 * @arg_lv_name: Argument to pass with the method invocation.
 * @arg_pool_name: Argument to pass with the method invocation.
 * @arg_data_size: Argument to pass with the method invocation.
 * @arg_virtual_size: Argument to pass with the method invocation.
 * @arg_index_memory: Argument to pass with the method invocation.
 * @arg_compression: Argument to pass with the method invocation.
 * @arg_deduplication: Argument to pass with the method invocation.
 * @arg_write_policy: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreateVDOVolume">CreateVDOVolume()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_call_create_vdo_volume() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_volume_group_call_create_vdo_volume_sync (
    UDisksVolumeGroup *proxy,
    const gchar *arg_lv_name,
    const gchar *arg_pool_name,
    guint64 arg_data_size,
    guint64 arg_virtual_size,
    guint64 arg_index_memory,
    gboolean arg_compression,
    gboolean arg_deduplication,
    const gchar *arg_write_policy,
    GVariant *arg_options,
    gchar ** out_result,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CreateVDOVolume",
    g_variant_new ("(sstttbbs@a{sv})",
                   arg_lv_name,
                   arg_pool_name,
                   arg_data_size,
                   arg_virtual_size,
                   arg_index_memory,
                   arg_compression,
                   arg_deduplication,
                   arg_write_policy,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_volume_group_complete_poll:
 * @object: A #UDisksVolumeGroup.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.Poll">Poll()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_complete_poll (
    UDisksVolumeGroup *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_volume_group_complete_delete:
 * @object: A #UDisksVolumeGroup.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.Delete">Delete()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_complete_delete (
    UDisksVolumeGroup *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_volume_group_complete_rename:
 * @object: A #UDisksVolumeGroup.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @result: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.Rename">Rename()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_complete_rename (
    UDisksVolumeGroup *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *result)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   result));
}

/**
 * udisks_volume_group_complete_add_device:
 * @object: A #UDisksVolumeGroup.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.AddDevice">AddDevice()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_complete_add_device (
    UDisksVolumeGroup *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_volume_group_complete_empty_device:
 * @object: A #UDisksVolumeGroup.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.EmptyDevice">EmptyDevice()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_complete_empty_device (
    UDisksVolumeGroup *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_volume_group_complete_remove_device:
 * @object: A #UDisksVolumeGroup.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.RemoveDevice">RemoveDevice()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_complete_remove_device (
    UDisksVolumeGroup *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_volume_group_complete_remove_missing_physical_volumes:
 * @object: A #UDisksVolumeGroup.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.RemoveMissingPhysicalVolumes">RemoveMissingPhysicalVolumes()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_complete_remove_missing_physical_volumes (
    UDisksVolumeGroup *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_volume_group_complete_create_plain_volume:
 * @object: A #UDisksVolumeGroup.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @result: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreatePlainVolume">CreatePlainVolume()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_complete_create_plain_volume (
    UDisksVolumeGroup *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *result)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   result));
}

/**
 * udisks_volume_group_complete_create_plain_volume_with_layout:
 * @object: A #UDisksVolumeGroup.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @result: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreatePlainVolumeWithLayout">CreatePlainVolumeWithLayout()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_complete_create_plain_volume_with_layout (
    UDisksVolumeGroup *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *result)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   result));
}

/**
 * udisks_volume_group_complete_create_thin_pool_volume:
 * @object: A #UDisksVolumeGroup.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @result: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreateThinPoolVolume">CreateThinPoolVolume()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_complete_create_thin_pool_volume (
    UDisksVolumeGroup *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *result)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   result));
}

/**
 * udisks_volume_group_complete_create_thin_volume:
 * @object: A #UDisksVolumeGroup.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @result: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreateThinVolume">CreateThinVolume()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_complete_create_thin_volume (
    UDisksVolumeGroup *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *result)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   result));
}

/**
 * udisks_volume_group_complete_create_vdo_volume:
 * @object: A #UDisksVolumeGroup.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @result: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VolumeGroup.CreateVDOVolume">CreateVDOVolume()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_complete_create_vdo_volume (
    UDisksVolumeGroup *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *result)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   result));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksVolumeGroupProxy:
 *
 * The #UDisksVolumeGroupProxy structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.0.0
 */

/**
 * UDisksVolumeGroupProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksVolumeGroupProxy.
 *
 * Since: 2.0.0
 */

struct _UDisksVolumeGroupProxyPrivate
{
  GData *qdata;
};

static void udisks_volume_group_proxy_iface_init (UDisksVolumeGroupIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksVolumeGroupProxy, udisks_volume_group_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksVolumeGroupProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_VOLUME_GROUP, udisks_volume_group_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksVolumeGroupProxy, udisks_volume_group_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_VOLUME_GROUP, udisks_volume_group_proxy_iface_init))

#endif
static void
udisks_volume_group_proxy_finalize (GObject *object)
{
  UDisksVolumeGroupProxy *proxy = UDISKS_VOLUME_GROUP_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_volume_group_proxy_parent_class)->finalize (object);
}

static void
udisks_volume_group_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 7);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_volume_group_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_volume_group_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.VolumeGroup: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_volume_group_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 7);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_volume_group_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.VolumeGroup", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_volume_group_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_volume_group_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_volume_group_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_VOLUME_GROUP);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_VOLUME_GROUP);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_volume_group_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksVolumeGroupProxy *proxy = UDISKS_VOLUME_GROUP_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_volume_group_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_volume_group_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_volume_group_proxy_get_name (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupProxy *proxy = UDISKS_VOLUME_GROUP_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Name");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_volume_group_proxy_get_uuid (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupProxy *proxy = UDISKS_VOLUME_GROUP_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "UUID");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_volume_group_proxy_get_size (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupProxy *proxy = UDISKS_VOLUME_GROUP_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Size");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_volume_group_proxy_get_free_size (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupProxy *proxy = UDISKS_VOLUME_GROUP_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "FreeSize");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_volume_group_proxy_get_extent_size (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupProxy *proxy = UDISKS_VOLUME_GROUP_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ExtentSize");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_volume_group_proxy_get_needs_polling (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupProxy *proxy = UDISKS_VOLUME_GROUP_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "NeedsPolling");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *const *
udisks_volume_group_proxy_get_missing_physical_volumes (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupProxy *proxy = UDISKS_VOLUME_GROUP_PROXY (object);
  GVariant *variant;
  const gchar *const *value = NULL;
  value = g_datalist_get_data (&proxy->priv->qdata, "MissingPhysicalVolumes");
  if (value != NULL)
    return value;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "MissingPhysicalVolumes");
  if (variant != NULL)
    {
      value = g_variant_get_strv (variant, NULL);
      g_datalist_set_data_full (&proxy->priv->qdata, "MissingPhysicalVolumes", (gpointer) value, g_free);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_volume_group_proxy_init (UDisksVolumeGroupProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_volume_group_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_VOLUME_GROUP_PROXY, UDisksVolumeGroupProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_volume_group_interface_info ());
}

static void
udisks_volume_group_proxy_class_init (UDisksVolumeGroupProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_volume_group_proxy_finalize;
  gobject_class->get_property = udisks_volume_group_proxy_get_property;
  gobject_class->set_property = udisks_volume_group_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_volume_group_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_volume_group_proxy_g_properties_changed;

  udisks_volume_group_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksVolumeGroupProxyPrivate));
#endif
}

static void
udisks_volume_group_proxy_iface_init (UDisksVolumeGroupIface *iface)
{
  iface->get_name = udisks_volume_group_proxy_get_name;
  iface->get_uuid = udisks_volume_group_proxy_get_uuid;
  iface->get_size = udisks_volume_group_proxy_get_size;
  iface->get_free_size = udisks_volume_group_proxy_get_free_size;
  iface->get_extent_size = udisks_volume_group_proxy_get_extent_size;
  iface->get_needs_polling = udisks_volume_group_proxy_get_needs_polling;
  iface->get_missing_physical_volumes = udisks_volume_group_proxy_get_missing_physical_volumes;
}

/**
 * udisks_volume_group_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VolumeGroup.top_of_page">org.freedesktop.UDisks2.VolumeGroup</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_volume_group_proxy_new_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_VOLUME_GROUP_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.VolumeGroup", NULL);
}

/**
 * udisks_volume_group_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_volume_group_proxy_new().
 *
 * Returns: (transfer full) (type UDisksVolumeGroupProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksVolumeGroup *
udisks_volume_group_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_VOLUME_GROUP (ret);
  else
    return NULL;
}

/**
 * udisks_volume_group_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VolumeGroup.top_of_page">org.freedesktop.UDisks2.VolumeGroup</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksVolumeGroupProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksVolumeGroup *
udisks_volume_group_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_VOLUME_GROUP_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.VolumeGroup", NULL);
  if (ret != NULL)
    return UDISKS_VOLUME_GROUP (ret);
  else
    return NULL;
}


/**
 * udisks_volume_group_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_volume_group_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_volume_group_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_volume_group_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.0.0
 */
void
udisks_volume_group_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_VOLUME_GROUP_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.VolumeGroup", NULL);
}

/**
 * udisks_volume_group_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_volume_group_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_volume_group_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksVolumeGroupProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksVolumeGroup *
udisks_volume_group_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_VOLUME_GROUP (ret);
  else
    return NULL;
}

/**
 * udisks_volume_group_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_volume_group_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_volume_group_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksVolumeGroupProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksVolumeGroup *
udisks_volume_group_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_VOLUME_GROUP_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.VolumeGroup", NULL);
  if (ret != NULL)
    return UDISKS_VOLUME_GROUP (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksVolumeGroupSkeleton:
 *
 * The #UDisksVolumeGroupSkeleton structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.0.0
 */

/**
 * UDisksVolumeGroupSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksVolumeGroupSkeleton.
 *
 * Since: 2.0.0
 */

struct _UDisksVolumeGroupSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_volume_group_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_VOLUME_GROUP);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_VOLUME_GROUP);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_volume_group_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_volume_group_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_volume_group_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_volume_group_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_volume_group_skeleton_vtable =
{
  _udisks_volume_group_skeleton_handle_method_call,
  _udisks_volume_group_skeleton_handle_get_property,
  _udisks_volume_group_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_volume_group_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_volume_group_interface_info ();
}

static GDBusInterfaceVTable *
udisks_volume_group_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_volume_group_skeleton_vtable;
}

static GVariant *
udisks_volume_group_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_volume_group_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_volume_group_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_volume_group_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_volume_group_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.VolumeGroup", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_volume_group_emit_changed (gpointer user_data);

static void
udisks_volume_group_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_volume_group_emit_changed (skeleton);
}

static void udisks_volume_group_skeleton_iface_init (UDisksVolumeGroupIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksVolumeGroupSkeleton, udisks_volume_group_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksVolumeGroupSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_VOLUME_GROUP, udisks_volume_group_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksVolumeGroupSkeleton, udisks_volume_group_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_VOLUME_GROUP, udisks_volume_group_skeleton_iface_init))

#endif
static void
udisks_volume_group_skeleton_finalize (GObject *object)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (object);
  guint n;
  for (n = 0; n < 7; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_volume_group_skeleton_parent_class)->finalize (object);
}

static void
udisks_volume_group_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 7);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_volume_group_emit_changed (gpointer user_data)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.VolumeGroup",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_volume_group_schedule_emit_changed (UDisksVolumeGroupSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_volume_group_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_volume_group_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_volume_group_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_volume_group_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 7);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_volume_group_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_volume_group_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_volume_group_skeleton_init (UDisksVolumeGroupSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_volume_group_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_VOLUME_GROUP_SKELETON, UDisksVolumeGroupSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 7);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[4], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[5], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[6], G_TYPE_STRV);
}

static const gchar *
udisks_volume_group_skeleton_get_name (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_volume_group_skeleton_get_uuid (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_volume_group_skeleton_get_size (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_volume_group_skeleton_get_free_size (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_volume_group_skeleton_get_extent_size (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[4]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_volume_group_skeleton_get_needs_polling (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[5]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *const *
udisks_volume_group_skeleton_get_missing_physical_volumes (UDisksVolumeGroup *object)
{
  UDisksVolumeGroupSkeleton *skeleton = UDISKS_VOLUME_GROUP_SKELETON (object);
  const gchar *const *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boxed (&(skeleton->priv->properties[6]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_volume_group_skeleton_class_init (UDisksVolumeGroupSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_volume_group_skeleton_finalize;
  gobject_class->get_property = udisks_volume_group_skeleton_get_property;
  gobject_class->set_property = udisks_volume_group_skeleton_set_property;
  gobject_class->notify       = udisks_volume_group_skeleton_notify;


  udisks_volume_group_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_volume_group_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_volume_group_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_volume_group_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_volume_group_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksVolumeGroupSkeletonPrivate));
#endif
}

static void
udisks_volume_group_skeleton_iface_init (UDisksVolumeGroupIface *iface)
{
  iface->get_name = udisks_volume_group_skeleton_get_name;
  iface->get_uuid = udisks_volume_group_skeleton_get_uuid;
  iface->get_size = udisks_volume_group_skeleton_get_size;
  iface->get_free_size = udisks_volume_group_skeleton_get_free_size;
  iface->get_extent_size = udisks_volume_group_skeleton_get_extent_size;
  iface->get_needs_polling = udisks_volume_group_skeleton_get_needs_polling;
  iface->get_missing_physical_volumes = udisks_volume_group_skeleton_get_missing_physical_volumes;
}

/**
 * udisks_volume_group_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VolumeGroup.top_of_page">org.freedesktop.UDisks2.VolumeGroup</link>.
 *
 * Returns: (transfer full) (type UDisksVolumeGroupSkeleton): The skeleton object.
 *
 * Since: 2.0.0
 */
UDisksVolumeGroup *
udisks_volume_group_skeleton_new (void)
{
  return UDISKS_VOLUME_GROUP (g_object_new (UDISKS_TYPE_VOLUME_GROUP_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.LogicalVolume
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksLogicalVolume
 * @title: UDisksLogicalVolume
 * @short_description: Generated C code for the org.freedesktop.UDisks2.LogicalVolume D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-LogicalVolume.top_of_page">org.freedesktop.UDisks2.LogicalVolume</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.LogicalVolume ---- */

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_activate_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_logical_volume_method_info_activate_IN_ARG_pointers[] =
{
  &_udisks_logical_volume_method_info_activate_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_activate_OUT_ARG_result =
{
  {
    -1,
    (gchar *) "result",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_logical_volume_method_info_activate_OUT_ARG_pointers[] =
{
  &_udisks_logical_volume_method_info_activate_OUT_ARG_result.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_logical_volume_method_info_activate =
{
  {
    -1,
    (gchar *) "Activate",
    (GDBusArgInfo **) &_udisks_logical_volume_method_info_activate_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_logical_volume_method_info_activate_OUT_ARG_pointers,
    NULL
  },
  "handle-activate",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_deactivate_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_logical_volume_method_info_deactivate_IN_ARG_pointers[] =
{
  &_udisks_logical_volume_method_info_deactivate_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_logical_volume_method_info_deactivate =
{
  {
    -1,
    (gchar *) "Deactivate",
    (GDBusArgInfo **) &_udisks_logical_volume_method_info_deactivate_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-deactivate",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_delete_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_logical_volume_method_info_delete_IN_ARG_pointers[] =
{
  &_udisks_logical_volume_method_info_delete_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_logical_volume_method_info_delete =
{
  {
    -1,
    (gchar *) "Delete",
    (GDBusArgInfo **) &_udisks_logical_volume_method_info_delete_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-delete",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_rename_IN_ARG_new_name =
{
  {
    -1,
    (gchar *) "new_name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_rename_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_logical_volume_method_info_rename_IN_ARG_pointers[] =
{
  &_udisks_logical_volume_method_info_rename_IN_ARG_new_name.parent_struct,
  &_udisks_logical_volume_method_info_rename_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_rename_OUT_ARG_result =
{
  {
    -1,
    (gchar *) "result",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_logical_volume_method_info_rename_OUT_ARG_pointers[] =
{
  &_udisks_logical_volume_method_info_rename_OUT_ARG_result.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_logical_volume_method_info_rename =
{
  {
    -1,
    (gchar *) "Rename",
    (GDBusArgInfo **) &_udisks_logical_volume_method_info_rename_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_logical_volume_method_info_rename_OUT_ARG_pointers,
    NULL
  },
  "handle-rename",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_resize_IN_ARG_new_size =
{
  {
    -1,
    (gchar *) "new_size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_resize_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_logical_volume_method_info_resize_IN_ARG_pointers[] =
{
  &_udisks_logical_volume_method_info_resize_IN_ARG_new_size.parent_struct,
  &_udisks_logical_volume_method_info_resize_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_logical_volume_method_info_resize =
{
  {
    -1,
    (gchar *) "Resize",
    (GDBusArgInfo **) &_udisks_logical_volume_method_info_resize_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-resize",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_repair_IN_ARG_pvs =
{
  {
    -1,
    (gchar *) "pvs",
    (gchar *) "ao",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_repair_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_logical_volume_method_info_repair_IN_ARG_pointers[] =
{
  &_udisks_logical_volume_method_info_repair_IN_ARG_pvs.parent_struct,
  &_udisks_logical_volume_method_info_repair_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_logical_volume_method_info_repair =
{
  {
    -1,
    (gchar *) "Repair",
    (GDBusArgInfo **) &_udisks_logical_volume_method_info_repair_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-repair",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_create_snapshot_IN_ARG_name =
{
  {
    -1,
    (gchar *) "name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_create_snapshot_IN_ARG_size =
{
  {
    -1,
    (gchar *) "size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_create_snapshot_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_logical_volume_method_info_create_snapshot_IN_ARG_pointers[] =
{
  &_udisks_logical_volume_method_info_create_snapshot_IN_ARG_name.parent_struct,
  &_udisks_logical_volume_method_info_create_snapshot_IN_ARG_size.parent_struct,
  &_udisks_logical_volume_method_info_create_snapshot_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_create_snapshot_OUT_ARG_result =
{
  {
    -1,
    (gchar *) "result",
    (gchar *) "o",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_logical_volume_method_info_create_snapshot_OUT_ARG_pointers[] =
{
  &_udisks_logical_volume_method_info_create_snapshot_OUT_ARG_result.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_logical_volume_method_info_create_snapshot =
{
  {
    -1,
    (gchar *) "CreateSnapshot",
    (GDBusArgInfo **) &_udisks_logical_volume_method_info_create_snapshot_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_logical_volume_method_info_create_snapshot_OUT_ARG_pointers,
    NULL
  },
  "handle-create-snapshot",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_cache_attach_IN_ARG_cache_name =
{
  {
    -1,
    (gchar *) "cache_name",
    (gchar *) "s",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_cache_attach_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_logical_volume_method_info_cache_attach_IN_ARG_pointers[] =
{
  &_udisks_logical_volume_method_info_cache_attach_IN_ARG_cache_name.parent_struct,
  &_udisks_logical_volume_method_info_cache_attach_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_logical_volume_method_info_cache_attach =
{
  {
    -1,
    (gchar *) "CacheAttach",
    (GDBusArgInfo **) &_udisks_logical_volume_method_info_cache_attach_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-cache-attach",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_cache_split_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_logical_volume_method_info_cache_split_IN_ARG_pointers[] =
{
  &_udisks_logical_volume_method_info_cache_split_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_logical_volume_method_info_cache_split =
{
  {
    -1,
    (gchar *) "CacheSplit",
    (GDBusArgInfo **) &_udisks_logical_volume_method_info_cache_split_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-cache-split",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_logical_volume_method_info_cache_detach_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_logical_volume_method_info_cache_detach_IN_ARG_pointers[] =
{
  &_udisks_logical_volume_method_info_cache_detach_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_logical_volume_method_info_cache_detach =
{
  {
    -1,
    (gchar *) "CacheDetach",
    (GDBusArgInfo **) &_udisks_logical_volume_method_info_cache_detach_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-cache-detach",
  FALSE
};

static const GDBusMethodInfo * const _udisks_logical_volume_method_info_pointers[] =
{
  &_udisks_logical_volume_method_info_activate.parent_struct,
  &_udisks_logical_volume_method_info_deactivate.parent_struct,
  &_udisks_logical_volume_method_info_delete.parent_struct,
  &_udisks_logical_volume_method_info_rename.parent_struct,
  &_udisks_logical_volume_method_info_resize.parent_struct,
  &_udisks_logical_volume_method_info_repair.parent_struct,
  &_udisks_logical_volume_method_info_create_snapshot.parent_struct,
  &_udisks_logical_volume_method_info_cache_attach.parent_struct,
  &_udisks_logical_volume_method_info_cache_split.parent_struct,
  &_udisks_logical_volume_method_info_cache_detach.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_volume_group =
{
  {
    -1,
    (gchar *) "VolumeGroup",
    (gchar *) "o",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "volume-group",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_name =
{
  {
    -1,
    (gchar *) "Name",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "name",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_active =
{
  {
    -1,
    (gchar *) "Active",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "active",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_uuid =
{
  {
    -1,
    (gchar *) "UUID",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "uuid",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_size =
{
  {
    -1,
    (gchar *) "Size",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "size",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_data_allocated_ratio =
{
  {
    -1,
    (gchar *) "DataAllocatedRatio",
    (gchar *) "d",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "data-allocated-ratio",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_metadata_allocated_ratio =
{
  {
    -1,
    (gchar *) "MetadataAllocatedRatio",
    (gchar *) "d",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "metadata-allocated-ratio",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_type_ =
{
  {
    -1,
    (gchar *) "Type",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "type",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_layout =
{
  {
    -1,
    (gchar *) "Layout",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "layout",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_structure =
{
  {
    -1,
    (gchar *) "Structure",
    (gchar *) "a{sv}",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "structure",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_sync_ratio =
{
  {
    -1,
    (gchar *) "SyncRatio",
    (gchar *) "d",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "sync-ratio",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_thin_pool =
{
  {
    -1,
    (gchar *) "ThinPool",
    (gchar *) "o",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "thin-pool",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_origin =
{
  {
    -1,
    (gchar *) "Origin",
    (gchar *) "o",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "origin",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_child_configuration =
{
  {
    -1,
    (gchar *) "ChildConfiguration",
    (gchar *) "a(sa{sv})",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "child-configuration",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_logical_volume_property_info_block_device =
{
  {
    -1,
    (gchar *) "BlockDevice",
    (gchar *) "o",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "block-device",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_logical_volume_property_info_pointers[] =
{
  &_udisks_logical_volume_property_info_volume_group.parent_struct,
  &_udisks_logical_volume_property_info_name.parent_struct,
  &_udisks_logical_volume_property_info_active.parent_struct,
  &_udisks_logical_volume_property_info_uuid.parent_struct,
  &_udisks_logical_volume_property_info_size.parent_struct,
  &_udisks_logical_volume_property_info_data_allocated_ratio.parent_struct,
  &_udisks_logical_volume_property_info_metadata_allocated_ratio.parent_struct,
  &_udisks_logical_volume_property_info_type_.parent_struct,
  &_udisks_logical_volume_property_info_layout.parent_struct,
  &_udisks_logical_volume_property_info_structure.parent_struct,
  &_udisks_logical_volume_property_info_sync_ratio.parent_struct,
  &_udisks_logical_volume_property_info_thin_pool.parent_struct,
  &_udisks_logical_volume_property_info_origin.parent_struct,
  &_udisks_logical_volume_property_info_child_configuration.parent_struct,
  &_udisks_logical_volume_property_info_block_device.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_logical_volume_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.LogicalVolume",
    (GDBusMethodInfo **) &_udisks_logical_volume_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_logical_volume_property_info_pointers,
    NULL
  },
  "logical-volume",
};


/**
 * udisks_logical_volume_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-LogicalVolume.top_of_page">org.freedesktop.UDisks2.LogicalVolume</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 *
 * Since: 2.0.0
 */
GDBusInterfaceInfo *
udisks_logical_volume_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_logical_volume_interface_info.parent_struct;
}

/**
 * udisks_logical_volume_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksLogicalVolume interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 *
 * Since: 2.0.0
 */
guint
udisks_logical_volume_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "volume-group");
  g_object_class_override_property (klass, property_id_begin++, "name");
  g_object_class_override_property (klass, property_id_begin++, "active");
  g_object_class_override_property (klass, property_id_begin++, "uuid");
  g_object_class_override_property (klass, property_id_begin++, "size");
  g_object_class_override_property (klass, property_id_begin++, "data-allocated-ratio");
  g_object_class_override_property (klass, property_id_begin++, "metadata-allocated-ratio");
  g_object_class_override_property (klass, property_id_begin++, "type");
  g_object_class_override_property (klass, property_id_begin++, "layout");
  g_object_class_override_property (klass, property_id_begin++, "structure");
  g_object_class_override_property (klass, property_id_begin++, "sync-ratio");
  g_object_class_override_property (klass, property_id_begin++, "thin-pool");
  g_object_class_override_property (klass, property_id_begin++, "origin");
  g_object_class_override_property (klass, property_id_begin++, "child-configuration");
  g_object_class_override_property (klass, property_id_begin++, "block-device");
  return property_id_begin - 1;
}


inline static void
udisks_logical_volume_method_marshal_activate (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_logical_volume_method_marshal_deactivate (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_logical_volume_method_marshal_delete (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_logical_volume_method_marshal_rename (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_logical_volume_method_marshal_resize (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT64_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_logical_volume_method_marshal_repair (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOXED_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_logical_volume_method_marshal_create_snapshot (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_UINT64_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_logical_volume_method_marshal_cache_attach (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_STRING_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_logical_volume_method_marshal_cache_split (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_logical_volume_method_marshal_cache_detach (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksLogicalVolume:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-LogicalVolume.top_of_page">org.freedesktop.UDisks2.LogicalVolume</link>.
 *
 * Since: 2.0.0
 */

/**
 * UDisksLogicalVolumeIface:
 * @parent_iface: The parent interface.
 * @handle_activate: Handler for the #UDisksLogicalVolume::handle-activate signal.
 * @handle_cache_attach: Handler for the #UDisksLogicalVolume::handle-cache-attach signal.
 * @handle_cache_detach: Handler for the #UDisksLogicalVolume::handle-cache-detach signal.
 * @handle_cache_split: Handler for the #UDisksLogicalVolume::handle-cache-split signal.
 * @handle_create_snapshot: Handler for the #UDisksLogicalVolume::handle-create-snapshot signal.
 * @handle_deactivate: Handler for the #UDisksLogicalVolume::handle-deactivate signal.
 * @handle_delete: Handler for the #UDisksLogicalVolume::handle-delete signal.
 * @handle_rename: Handler for the #UDisksLogicalVolume::handle-rename signal.
 * @handle_repair: Handler for the #UDisksLogicalVolume::handle-repair signal.
 * @handle_resize: Handler for the #UDisksLogicalVolume::handle-resize signal.
 * @get_active: Getter for the #UDisksLogicalVolume:active property.
 * @get_block_device: Getter for the #UDisksLogicalVolume:block-device property.
 * @get_child_configuration: Getter for the #UDisksLogicalVolume:child-configuration property.
 * @get_data_allocated_ratio: Getter for the #UDisksLogicalVolume:data-allocated-ratio property.
 * @get_layout: Getter for the #UDisksLogicalVolume:layout property.
 * @get_metadata_allocated_ratio: Getter for the #UDisksLogicalVolume:metadata-allocated-ratio property.
 * @get_name: Getter for the #UDisksLogicalVolume:name property.
 * @get_origin: Getter for the #UDisksLogicalVolume:origin property.
 * @get_size: Getter for the #UDisksLogicalVolume:size property.
 * @get_structure: Getter for the #UDisksLogicalVolume:structure property.
 * @get_sync_ratio: Getter for the #UDisksLogicalVolume:sync-ratio property.
 * @get_thin_pool: Getter for the #UDisksLogicalVolume:thin-pool property.
 * @get_type_: Getter for the #UDisksLogicalVolume:type property.
 * @get_uuid: Getter for the #UDisksLogicalVolume:uuid property.
 * @get_volume_group: Getter for the #UDisksLogicalVolume:volume-group property.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-LogicalVolume.top_of_page">org.freedesktop.UDisks2.LogicalVolume</link>.
 *
 * Since: 2.0.0
 */

typedef UDisksLogicalVolumeIface UDisksLogicalVolumeInterface;
G_DEFINE_INTERFACE (UDisksLogicalVolume, udisks_logical_volume, G_TYPE_OBJECT)

static void
udisks_logical_volume_default_init (UDisksLogicalVolumeIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksLogicalVolume::handle-activate:
   * @object: A #UDisksLogicalVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Activate">Activate()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_logical_volume_complete_activate() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-activate",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksLogicalVolumeIface, handle_activate),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_logical_volume_method_marshal_activate,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksLogicalVolume::handle-deactivate:
   * @object: A #UDisksLogicalVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Deactivate">Deactivate()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_logical_volume_complete_deactivate() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-deactivate",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksLogicalVolumeIface, handle_deactivate),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_logical_volume_method_marshal_deactivate,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksLogicalVolume::handle-delete:
   * @object: A #UDisksLogicalVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Delete">Delete()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_logical_volume_complete_delete() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-delete",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksLogicalVolumeIface, handle_delete),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_logical_volume_method_marshal_delete,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksLogicalVolume::handle-rename:
   * @object: A #UDisksLogicalVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_new_name: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Rename">Rename()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_logical_volume_complete_rename() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-rename",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksLogicalVolumeIface, handle_rename),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_logical_volume_method_marshal_rename,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksLogicalVolume::handle-resize:
   * @object: A #UDisksLogicalVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_new_size: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Resize">Resize()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_logical_volume_complete_resize() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-resize",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksLogicalVolumeIface, handle_resize),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_logical_volume_method_marshal_resize,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT64, G_TYPE_VARIANT);

  /**
   * UDisksLogicalVolume::handle-repair:
   * @object: A #UDisksLogicalVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_pvs: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Repair">Repair()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_logical_volume_complete_repair() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-repair",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksLogicalVolumeIface, handle_repair),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_logical_volume_method_marshal_repair,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRV, G_TYPE_VARIANT);

  /**
   * UDisksLogicalVolume::handle-create-snapshot:
   * @object: A #UDisksLogicalVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_name: Argument passed by remote caller.
   * @arg_size: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CreateSnapshot">CreateSnapshot()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_logical_volume_complete_create_snapshot() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-create-snapshot",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksLogicalVolumeIface, handle_create_snapshot),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_logical_volume_method_marshal_create_snapshot,
    G_TYPE_BOOLEAN,
    4,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_VARIANT);

  /**
   * UDisksLogicalVolume::handle-cache-attach:
   * @object: A #UDisksLogicalVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_cache_name: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CacheAttach">CacheAttach()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_logical_volume_complete_cache_attach() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-cache-attach",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksLogicalVolumeIface, handle_cache_attach),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_logical_volume_method_marshal_cache_attach,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_VARIANT);

  /**
   * UDisksLogicalVolume::handle-cache-split:
   * @object: A #UDisksLogicalVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CacheSplit">CacheSplit()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_logical_volume_complete_cache_split() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-cache-split",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksLogicalVolumeIface, handle_cache_split),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_logical_volume_method_marshal_cache_split,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /**
   * UDisksLogicalVolume::handle-cache-detach:
   * @object: A #UDisksLogicalVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CacheDetach">CacheDetach()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_logical_volume_complete_cache_detach() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.0.0
   */
  g_signal_new ("handle-cache-detach",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksLogicalVolumeIface, handle_cache_detach),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_logical_volume_method_marshal_cache_detach,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksLogicalVolume:volume-group:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.VolumeGroup">"VolumeGroup"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("volume-group", "VolumeGroup", "VolumeGroup", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:name:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Name">"Name"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("name", "Name", "Name", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:active:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Active">"Active"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("active", "Active", "Active", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:uuid:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.UUID">"UUID"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("uuid", "UUID", "UUID", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Size">"Size"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("size", "Size", "Size", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:data-allocated-ratio:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.DataAllocatedRatio">"DataAllocatedRatio"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_double ("data-allocated-ratio", "DataAllocatedRatio", "DataAllocatedRatio", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:metadata-allocated-ratio:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.MetadataAllocatedRatio">"MetadataAllocatedRatio"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_double ("metadata-allocated-ratio", "MetadataAllocatedRatio", "MetadataAllocatedRatio", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:type:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Type">"Type"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("type", "Type", "Type", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:layout:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Layout">"Layout"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("layout", "Layout", "Layout", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:structure:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Structure">"Structure"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_variant ("structure", "Structure", "Structure", G_VARIANT_TYPE ("a{sv}"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:sync-ratio:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.SyncRatio">"SyncRatio"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_double ("sync-ratio", "SyncRatio", "SyncRatio", -G_MAXDOUBLE, G_MAXDOUBLE, 0.0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:thin-pool:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.ThinPool">"ThinPool"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("thin-pool", "ThinPool", "ThinPool", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:origin:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Origin">"Origin"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("origin", "Origin", "Origin", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:child-configuration:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.ChildConfiguration">"ChildConfiguration"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_variant ("child-configuration", "ChildConfiguration", "ChildConfiguration", G_VARIANT_TYPE ("a(sa{sv})"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksLogicalVolume:block-device:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.BlockDevice">"BlockDevice"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("block-device", "BlockDevice", "BlockDevice", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_logical_volume_get_volume_group: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.VolumeGroup">"VolumeGroup"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_logical_volume_dup_volume_group() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_logical_volume_get_volume_group (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), NULL);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_volume_group (object);
}

/**
 * udisks_logical_volume_dup_volume_group: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.VolumeGroup">"VolumeGroup"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_logical_volume_dup_volume_group (UDisksLogicalVolume *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "volume-group", &value, NULL);
  return value;
}

/**
 * udisks_logical_volume_set_volume_group: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.VolumeGroup">"VolumeGroup"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_volume_group (UDisksLogicalVolume *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "volume-group", value, NULL);
}

/**
 * udisks_logical_volume_get_name: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Name">"Name"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_logical_volume_dup_name() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_logical_volume_get_name (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), NULL);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_name (object);
}

/**
 * udisks_logical_volume_dup_name: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Name">"Name"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_logical_volume_dup_name (UDisksLogicalVolume *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "name", &value, NULL);
  return value;
}

/**
 * udisks_logical_volume_set_name: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Name">"Name"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_name (UDisksLogicalVolume *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "name", value, NULL);
}

/**
 * udisks_logical_volume_get_active: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Active">"Active"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
gboolean 
udisks_logical_volume_get_active (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), FALSE);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_active (object);
}

/**
 * udisks_logical_volume_set_active: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Active">"Active"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_active (UDisksLogicalVolume *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "active", value, NULL);
}

/**
 * udisks_logical_volume_get_uuid: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.UUID">"UUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_logical_volume_dup_uuid() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_logical_volume_get_uuid (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), NULL);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_uuid (object);
}

/**
 * udisks_logical_volume_dup_uuid: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.UUID">"UUID"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_logical_volume_dup_uuid (UDisksLogicalVolume *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "uuid", &value, NULL);
  return value;
}

/**
 * udisks_logical_volume_set_uuid: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.UUID">"UUID"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_uuid (UDisksLogicalVolume *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "uuid", value, NULL);
}

/**
 * udisks_logical_volume_get_size: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Size">"Size"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
guint64 
udisks_logical_volume_get_size (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), 0);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_size (object);
}

/**
 * udisks_logical_volume_set_size: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Size">"Size"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_size (UDisksLogicalVolume *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "size", value, NULL);
}

/**
 * udisks_logical_volume_get_data_allocated_ratio: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.DataAllocatedRatio">"DataAllocatedRatio"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
gdouble 
udisks_logical_volume_get_data_allocated_ratio (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), 0.0);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_data_allocated_ratio (object);
}

/**
 * udisks_logical_volume_set_data_allocated_ratio: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.DataAllocatedRatio">"DataAllocatedRatio"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_data_allocated_ratio (UDisksLogicalVolume *object, gdouble value)
{
  g_object_set (G_OBJECT (object), "data-allocated-ratio", value, NULL);
}

/**
 * udisks_logical_volume_get_metadata_allocated_ratio: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.MetadataAllocatedRatio">"MetadataAllocatedRatio"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
gdouble 
udisks_logical_volume_get_metadata_allocated_ratio (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), 0.0);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_metadata_allocated_ratio (object);
}

/**
 * udisks_logical_volume_set_metadata_allocated_ratio: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.MetadataAllocatedRatio">"MetadataAllocatedRatio"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_metadata_allocated_ratio (UDisksLogicalVolume *object, gdouble value)
{
  g_object_set (G_OBJECT (object), "metadata-allocated-ratio", value, NULL);
}

/**
 * udisks_logical_volume_get_type_: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Type">"Type"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_logical_volume_dup_type_() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_logical_volume_get_type_ (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), NULL);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_type_ (object);
}

/**
 * udisks_logical_volume_dup_type_: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Type">"Type"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_logical_volume_dup_type_ (UDisksLogicalVolume *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "type", &value, NULL);
  return value;
}

/**
 * udisks_logical_volume_set_type_: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Type">"Type"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_type_ (UDisksLogicalVolume *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "type", value, NULL);
}

/**
 * udisks_logical_volume_get_layout: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Layout">"Layout"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_logical_volume_dup_layout() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_logical_volume_get_layout (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), NULL);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_layout (object);
}

/**
 * udisks_logical_volume_dup_layout: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Layout">"Layout"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_logical_volume_dup_layout (UDisksLogicalVolume *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "layout", &value, NULL);
  return value;
}

/**
 * udisks_logical_volume_set_layout: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Layout">"Layout"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_layout (UDisksLogicalVolume *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "layout", value, NULL);
}

/**
 * udisks_logical_volume_get_structure: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Structure">"Structure"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_logical_volume_dup_structure() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
GVariant *
udisks_logical_volume_get_structure (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), NULL);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_structure (object);
}

/**
 * udisks_logical_volume_dup_structure: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Structure">"Structure"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_variant_unref().
 *
 * Since: 2.0.0
 */
GVariant *
udisks_logical_volume_dup_structure (UDisksLogicalVolume *object)
{
  GVariant *value;
  g_object_get (G_OBJECT (object), "structure", &value, NULL);
  return value;
}

/**
 * udisks_logical_volume_set_structure: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Structure">"Structure"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_structure (UDisksLogicalVolume *object, GVariant *value)
{
  g_object_set (G_OBJECT (object), "structure", value, NULL);
}

/**
 * udisks_logical_volume_get_sync_ratio: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.SyncRatio">"SyncRatio"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.0.0
 */
gdouble 
udisks_logical_volume_get_sync_ratio (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), 0.0);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_sync_ratio (object);
}

/**
 * udisks_logical_volume_set_sync_ratio: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.SyncRatio">"SyncRatio"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_sync_ratio (UDisksLogicalVolume *object, gdouble value)
{
  g_object_set (G_OBJECT (object), "sync-ratio", value, NULL);
}

/**
 * udisks_logical_volume_get_thin_pool: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.ThinPool">"ThinPool"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_logical_volume_dup_thin_pool() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_logical_volume_get_thin_pool (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), NULL);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_thin_pool (object);
}

/**
 * udisks_logical_volume_dup_thin_pool: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.ThinPool">"ThinPool"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_logical_volume_dup_thin_pool (UDisksLogicalVolume *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "thin-pool", &value, NULL);
  return value;
}

/**
 * udisks_logical_volume_set_thin_pool: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.ThinPool">"ThinPool"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_thin_pool (UDisksLogicalVolume *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "thin-pool", value, NULL);
}

/**
 * udisks_logical_volume_get_origin: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Origin">"Origin"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_logical_volume_dup_origin() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_logical_volume_get_origin (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), NULL);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_origin (object);
}

/**
 * udisks_logical_volume_dup_origin: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Origin">"Origin"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_logical_volume_dup_origin (UDisksLogicalVolume *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "origin", &value, NULL);
  return value;
}

/**
 * udisks_logical_volume_set_origin: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.Origin">"Origin"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_origin (UDisksLogicalVolume *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "origin", value, NULL);
}

/**
 * udisks_logical_volume_get_child_configuration: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.ChildConfiguration">"ChildConfiguration"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_logical_volume_dup_child_configuration() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
GVariant *
udisks_logical_volume_get_child_configuration (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), NULL);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_child_configuration (object);
}

/**
 * udisks_logical_volume_dup_child_configuration: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.ChildConfiguration">"ChildConfiguration"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_variant_unref().
 *
 * Since: 2.0.0
 */
GVariant *
udisks_logical_volume_dup_child_configuration (UDisksLogicalVolume *object)
{
  GVariant *value;
  g_object_get (G_OBJECT (object), "child-configuration", &value, NULL);
  return value;
}

/**
 * udisks_logical_volume_set_child_configuration: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.ChildConfiguration">"ChildConfiguration"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_child_configuration (UDisksLogicalVolume *object, GVariant *value)
{
  g_object_set (G_OBJECT (object), "child-configuration", value, NULL);
}

/**
 * udisks_logical_volume_get_block_device: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.BlockDevice">"BlockDevice"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_logical_volume_dup_block_device() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.0.0
 */
const gchar *
udisks_logical_volume_get_block_device (UDisksLogicalVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_LOGICAL_VOLUME (object), NULL);

  return UDISKS_LOGICAL_VOLUME_GET_IFACE (object)->get_block_device (object);
}

/**
 * udisks_logical_volume_dup_block_device: (skip)
 * @object: A #UDisksLogicalVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.BlockDevice">"BlockDevice"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.0.0
 */
gchar *
udisks_logical_volume_dup_block_device (UDisksLogicalVolume *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "block-device", &value, NULL);
  return value;
}

/**
 * udisks_logical_volume_set_block_device: (skip)
 * @object: A #UDisksLogicalVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-LogicalVolume.BlockDevice">"BlockDevice"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_set_block_device (UDisksLogicalVolume *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "block-device", value, NULL);
}

/**
 * udisks_logical_volume_call_activate:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Activate">Activate()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_logical_volume_call_activate_finish() to get the result of the operation.
 *
 * See udisks_logical_volume_call_activate_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_call_activate (
    UDisksLogicalVolume *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Activate",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_logical_volume_call_activate_finish:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_logical_volume_call_activate().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_logical_volume_call_activate().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_activate_finish (
    UDisksLogicalVolume *proxy,
    gchar ** out_result,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_activate_sync:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Activate">Activate()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_logical_volume_call_activate() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_activate_sync (
    UDisksLogicalVolume *proxy,
    GVariant *arg_options,
    gchar ** out_result,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Activate",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_deactivate:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Deactivate">Deactivate()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_logical_volume_call_deactivate_finish() to get the result of the operation.
 *
 * See udisks_logical_volume_call_deactivate_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_call_deactivate (
    UDisksLogicalVolume *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Deactivate",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_logical_volume_call_deactivate_finish:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_logical_volume_call_deactivate().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_logical_volume_call_deactivate().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_deactivate_finish (
    UDisksLogicalVolume *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_deactivate_sync:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Deactivate">Deactivate()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_logical_volume_call_deactivate() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_deactivate_sync (
    UDisksLogicalVolume *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Deactivate",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_delete:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Delete">Delete()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_logical_volume_call_delete_finish() to get the result of the operation.
 *
 * See udisks_logical_volume_call_delete_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_call_delete (
    UDisksLogicalVolume *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Delete",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_logical_volume_call_delete_finish:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_logical_volume_call_delete().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_logical_volume_call_delete().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_delete_finish (
    UDisksLogicalVolume *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_delete_sync:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Delete">Delete()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_logical_volume_call_delete() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_delete_sync (
    UDisksLogicalVolume *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Delete",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_rename:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_new_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Rename">Rename()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_logical_volume_call_rename_finish() to get the result of the operation.
 *
 * See udisks_logical_volume_call_rename_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_call_rename (
    UDisksLogicalVolume *proxy,
    const gchar *arg_new_name,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Rename",
    g_variant_new ("(s@a{sv})",
                   arg_new_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_logical_volume_call_rename_finish:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_logical_volume_call_rename().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_logical_volume_call_rename().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_rename_finish (
    UDisksLogicalVolume *proxy,
    gchar ** out_result,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_rename_sync:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_new_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Rename">Rename()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_logical_volume_call_rename() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_rename_sync (
    UDisksLogicalVolume *proxy,
    const gchar *arg_new_name,
    GVariant *arg_options,
    gchar ** out_result,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Rename",
    g_variant_new ("(s@a{sv})",
                   arg_new_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_resize:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_new_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Resize">Resize()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_logical_volume_call_resize_finish() to get the result of the operation.
 *
 * See udisks_logical_volume_call_resize_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_call_resize (
    UDisksLogicalVolume *proxy,
    guint64 arg_new_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Resize",
    g_variant_new ("(t@a{sv})",
                   arg_new_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_logical_volume_call_resize_finish:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_logical_volume_call_resize().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_logical_volume_call_resize().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_resize_finish (
    UDisksLogicalVolume *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_resize_sync:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_new_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Resize">Resize()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_logical_volume_call_resize() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_resize_sync (
    UDisksLogicalVolume *proxy,
    guint64 arg_new_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Resize",
    g_variant_new ("(t@a{sv})",
                   arg_new_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_repair:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_pvs: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Repair">Repair()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_logical_volume_call_repair_finish() to get the result of the operation.
 *
 * See udisks_logical_volume_call_repair_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_call_repair (
    UDisksLogicalVolume *proxy,
    const gchar *const *arg_pvs,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "Repair",
    g_variant_new ("(^ao@a{sv})",
                   arg_pvs,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_logical_volume_call_repair_finish:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_logical_volume_call_repair().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_logical_volume_call_repair().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_repair_finish (
    UDisksLogicalVolume *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_repair_sync:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_pvs: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Repair">Repair()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_logical_volume_call_repair() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_repair_sync (
    UDisksLogicalVolume *proxy,
    const gchar *const *arg_pvs,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "Repair",
    g_variant_new ("(^ao@a{sv})",
                   arg_pvs,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_create_snapshot:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CreateSnapshot">CreateSnapshot()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_logical_volume_call_create_snapshot_finish() to get the result of the operation.
 *
 * See udisks_logical_volume_call_create_snapshot_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_call_create_snapshot (
    UDisksLogicalVolume *proxy,
    const gchar *arg_name,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CreateSnapshot",
    g_variant_new ("(st@a{sv})",
                   arg_name,
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_logical_volume_call_create_snapshot_finish:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_logical_volume_call_create_snapshot().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_logical_volume_call_create_snapshot().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_create_snapshot_finish (
    UDisksLogicalVolume *proxy,
    gchar ** out_result,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_create_snapshot_sync:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_name: Argument to pass with the method invocation.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @out_result: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CreateSnapshot">CreateSnapshot()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_logical_volume_call_create_snapshot() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_create_snapshot_sync (
    UDisksLogicalVolume *proxy,
    const gchar *arg_name,
    guint64 arg_size,
    GVariant *arg_options,
    gchar ** out_result,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CreateSnapshot",
    g_variant_new ("(st@a{sv})",
                   arg_name,
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(o)",
                 out_result);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_cache_attach:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_cache_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CacheAttach">CacheAttach()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_logical_volume_call_cache_attach_finish() to get the result of the operation.
 *
 * See udisks_logical_volume_call_cache_attach_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_call_cache_attach (
    UDisksLogicalVolume *proxy,
    const gchar *arg_cache_name,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CacheAttach",
    g_variant_new ("(s@a{sv})",
                   arg_cache_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_logical_volume_call_cache_attach_finish:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_logical_volume_call_cache_attach().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_logical_volume_call_cache_attach().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_cache_attach_finish (
    UDisksLogicalVolume *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_cache_attach_sync:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_cache_name: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CacheAttach">CacheAttach()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_logical_volume_call_cache_attach() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_cache_attach_sync (
    UDisksLogicalVolume *proxy,
    const gchar *arg_cache_name,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CacheAttach",
    g_variant_new ("(s@a{sv})",
                   arg_cache_name,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_cache_split:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CacheSplit">CacheSplit()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_logical_volume_call_cache_split_finish() to get the result of the operation.
 *
 * See udisks_logical_volume_call_cache_split_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_call_cache_split (
    UDisksLogicalVolume *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CacheSplit",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_logical_volume_call_cache_split_finish:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_logical_volume_call_cache_split().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_logical_volume_call_cache_split().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_cache_split_finish (
    UDisksLogicalVolume *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_cache_split_sync:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CacheSplit">CacheSplit()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_logical_volume_call_cache_split() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_cache_split_sync (
    UDisksLogicalVolume *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CacheSplit",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_cache_detach:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CacheDetach">CacheDetach()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_logical_volume_call_cache_detach_finish() to get the result of the operation.
 *
 * See udisks_logical_volume_call_cache_detach_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_call_cache_detach (
    UDisksLogicalVolume *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "CacheDetach",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_logical_volume_call_cache_detach_finish:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_logical_volume_call_cache_detach().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_logical_volume_call_cache_detach().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_cache_detach_finish (
    UDisksLogicalVolume *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_call_cache_detach_sync:
 * @proxy: A #UDisksLogicalVolumeProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CacheDetach">CacheDetach()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_logical_volume_call_cache_detach() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.0.0
 */
gboolean
udisks_logical_volume_call_cache_detach_sync (
    UDisksLogicalVolume *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "CacheDetach",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_logical_volume_complete_activate:
 * @object: A #UDisksLogicalVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @result: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Activate">Activate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_complete_activate (
    UDisksLogicalVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *result)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   result));
}

/**
 * udisks_logical_volume_complete_deactivate:
 * @object: A #UDisksLogicalVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Deactivate">Deactivate()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_complete_deactivate (
    UDisksLogicalVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_logical_volume_complete_delete:
 * @object: A #UDisksLogicalVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Delete">Delete()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_complete_delete (
    UDisksLogicalVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_logical_volume_complete_rename:
 * @object: A #UDisksLogicalVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @result: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Rename">Rename()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_complete_rename (
    UDisksLogicalVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *result)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   result));
}

/**
 * udisks_logical_volume_complete_resize:
 * @object: A #UDisksLogicalVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Resize">Resize()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_complete_resize (
    UDisksLogicalVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_logical_volume_complete_repair:
 * @object: A #UDisksLogicalVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.Repair">Repair()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_complete_repair (
    UDisksLogicalVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_logical_volume_complete_create_snapshot:
 * @object: A #UDisksLogicalVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @result: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CreateSnapshot">CreateSnapshot()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_complete_create_snapshot (
    UDisksLogicalVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    const gchar *result)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(o)",
                   result));
}

/**
 * udisks_logical_volume_complete_cache_attach:
 * @object: A #UDisksLogicalVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CacheAttach">CacheAttach()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_complete_cache_attach (
    UDisksLogicalVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_logical_volume_complete_cache_split:
 * @object: A #UDisksLogicalVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CacheSplit">CacheSplit()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_complete_cache_split (
    UDisksLogicalVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_logical_volume_complete_cache_detach:
 * @object: A #UDisksLogicalVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-LogicalVolume.CacheDetach">CacheDetach()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_complete_cache_detach (
    UDisksLogicalVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksLogicalVolumeProxy:
 *
 * The #UDisksLogicalVolumeProxy structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.0.0
 */

/**
 * UDisksLogicalVolumeProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksLogicalVolumeProxy.
 *
 * Since: 2.0.0
 */

struct _UDisksLogicalVolumeProxyPrivate
{
  GData *qdata;
};

static void udisks_logical_volume_proxy_iface_init (UDisksLogicalVolumeIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksLogicalVolumeProxy, udisks_logical_volume_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksLogicalVolumeProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_LOGICAL_VOLUME, udisks_logical_volume_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksLogicalVolumeProxy, udisks_logical_volume_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_LOGICAL_VOLUME, udisks_logical_volume_proxy_iface_init))

#endif
static void
udisks_logical_volume_proxy_finalize (GObject *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_logical_volume_proxy_parent_class)->finalize (object);
}

static void
udisks_logical_volume_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 15);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_logical_volume_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_logical_volume_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.LogicalVolume: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_logical_volume_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 15);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_logical_volume_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.LogicalVolume", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_logical_volume_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_logical_volume_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_logical_volume_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_LOGICAL_VOLUME);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_LOGICAL_VOLUME);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_logical_volume_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_logical_volume_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_logical_volume_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_logical_volume_proxy_get_volume_group (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "VolumeGroup");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_logical_volume_proxy_get_name (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Name");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_logical_volume_proxy_get_active (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Active");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_logical_volume_proxy_get_uuid (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "UUID");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_logical_volume_proxy_get_size (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Size");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gdouble 
udisks_logical_volume_proxy_get_data_allocated_ratio (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  gdouble value = 0.0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "DataAllocatedRatio");
  if (variant != NULL)
    {
      value = g_variant_get_double (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gdouble 
udisks_logical_volume_proxy_get_metadata_allocated_ratio (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  gdouble value = 0.0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "MetadataAllocatedRatio");
  if (variant != NULL)
    {
      value = g_variant_get_double (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_logical_volume_proxy_get_type_ (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Type");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_logical_volume_proxy_get_layout (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Layout");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static GVariant *
udisks_logical_volume_proxy_get_structure (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  GVariant *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Structure");
  value = variant;
  if (variant != NULL)
    g_variant_unref (variant);
  return value;
}

static gdouble 
udisks_logical_volume_proxy_get_sync_ratio (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  gdouble value = 0.0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SyncRatio");
  if (variant != NULL)
    {
      value = g_variant_get_double (variant);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_logical_volume_proxy_get_thin_pool (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ThinPool");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_logical_volume_proxy_get_origin (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Origin");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static GVariant *
udisks_logical_volume_proxy_get_child_configuration (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  GVariant *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "ChildConfiguration");
  value = variant;
  if (variant != NULL)
    g_variant_unref (variant);
  return value;
}

static const gchar *
udisks_logical_volume_proxy_get_block_device (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeProxy *proxy = UDISKS_LOGICAL_VOLUME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "BlockDevice");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_logical_volume_proxy_init (UDisksLogicalVolumeProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_logical_volume_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_LOGICAL_VOLUME_PROXY, UDisksLogicalVolumeProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_logical_volume_interface_info ());
}

static void
udisks_logical_volume_proxy_class_init (UDisksLogicalVolumeProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_logical_volume_proxy_finalize;
  gobject_class->get_property = udisks_logical_volume_proxy_get_property;
  gobject_class->set_property = udisks_logical_volume_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_logical_volume_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_logical_volume_proxy_g_properties_changed;

  udisks_logical_volume_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksLogicalVolumeProxyPrivate));
#endif
}

static void
udisks_logical_volume_proxy_iface_init (UDisksLogicalVolumeIface *iface)
{
  iface->get_volume_group = udisks_logical_volume_proxy_get_volume_group;
  iface->get_name = udisks_logical_volume_proxy_get_name;
  iface->get_active = udisks_logical_volume_proxy_get_active;
  iface->get_uuid = udisks_logical_volume_proxy_get_uuid;
  iface->get_size = udisks_logical_volume_proxy_get_size;
  iface->get_data_allocated_ratio = udisks_logical_volume_proxy_get_data_allocated_ratio;
  iface->get_metadata_allocated_ratio = udisks_logical_volume_proxy_get_metadata_allocated_ratio;
  iface->get_type_ = udisks_logical_volume_proxy_get_type_;
  iface->get_layout = udisks_logical_volume_proxy_get_layout;
  iface->get_structure = udisks_logical_volume_proxy_get_structure;
  iface->get_sync_ratio = udisks_logical_volume_proxy_get_sync_ratio;
  iface->get_thin_pool = udisks_logical_volume_proxy_get_thin_pool;
  iface->get_origin = udisks_logical_volume_proxy_get_origin;
  iface->get_child_configuration = udisks_logical_volume_proxy_get_child_configuration;
  iface->get_block_device = udisks_logical_volume_proxy_get_block_device;
}

/**
 * udisks_logical_volume_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-LogicalVolume.top_of_page">org.freedesktop.UDisks2.LogicalVolume</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_logical_volume_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_logical_volume_proxy_new_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_LOGICAL_VOLUME_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.LogicalVolume", NULL);
}

/**
 * udisks_logical_volume_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_logical_volume_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_logical_volume_proxy_new().
 *
 * Returns: (transfer full) (type UDisksLogicalVolumeProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksLogicalVolume *
udisks_logical_volume_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_LOGICAL_VOLUME (ret);
  else
    return NULL;
}

/**
 * udisks_logical_volume_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-LogicalVolume.top_of_page">org.freedesktop.UDisks2.LogicalVolume</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_logical_volume_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksLogicalVolumeProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksLogicalVolume *
udisks_logical_volume_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_LOGICAL_VOLUME_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.LogicalVolume", NULL);
  if (ret != NULL)
    return UDISKS_LOGICAL_VOLUME (ret);
  else
    return NULL;
}


/**
 * udisks_logical_volume_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_logical_volume_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_logical_volume_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_logical_volume_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.0.0
 */
void
udisks_logical_volume_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_LOGICAL_VOLUME_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.LogicalVolume", NULL);
}

/**
 * udisks_logical_volume_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_logical_volume_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_logical_volume_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksLogicalVolumeProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksLogicalVolume *
udisks_logical_volume_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_LOGICAL_VOLUME (ret);
  else
    return NULL;
}

/**
 * udisks_logical_volume_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_logical_volume_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_logical_volume_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksLogicalVolumeProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.0.0
 */
UDisksLogicalVolume *
udisks_logical_volume_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_LOGICAL_VOLUME_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.LogicalVolume", NULL);
  if (ret != NULL)
    return UDISKS_LOGICAL_VOLUME (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksLogicalVolumeSkeleton:
 *
 * The #UDisksLogicalVolumeSkeleton structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.0.0
 */

/**
 * UDisksLogicalVolumeSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksLogicalVolumeSkeleton.
 *
 * Since: 2.0.0
 */

struct _UDisksLogicalVolumeSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_logical_volume_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_LOGICAL_VOLUME);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_LOGICAL_VOLUME);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_logical_volume_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_logical_volume_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_logical_volume_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_logical_volume_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_logical_volume_skeleton_vtable =
{
  _udisks_logical_volume_skeleton_handle_method_call,
  _udisks_logical_volume_skeleton_handle_get_property,
  _udisks_logical_volume_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_logical_volume_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_logical_volume_interface_info ();
}

static GDBusInterfaceVTable *
udisks_logical_volume_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_logical_volume_skeleton_vtable;
}

static GVariant *
udisks_logical_volume_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_logical_volume_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_logical_volume_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_logical_volume_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_logical_volume_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.LogicalVolume", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_logical_volume_emit_changed (gpointer user_data);

static void
udisks_logical_volume_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_logical_volume_emit_changed (skeleton);
}

static void udisks_logical_volume_skeleton_iface_init (UDisksLogicalVolumeIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksLogicalVolumeSkeleton, udisks_logical_volume_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksLogicalVolumeSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_LOGICAL_VOLUME, udisks_logical_volume_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksLogicalVolumeSkeleton, udisks_logical_volume_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_LOGICAL_VOLUME, udisks_logical_volume_skeleton_iface_init))

#endif
static void
udisks_logical_volume_skeleton_finalize (GObject *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  guint n;
  for (n = 0; n < 15; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_logical_volume_skeleton_parent_class)->finalize (object);
}

static void
udisks_logical_volume_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 15);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_logical_volume_emit_changed (gpointer user_data)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.LogicalVolume",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_logical_volume_schedule_emit_changed (UDisksLogicalVolumeSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_logical_volume_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_logical_volume_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_logical_volume_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_logical_volume_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 15);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_logical_volume_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_logical_volume_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_logical_volume_skeleton_init (UDisksLogicalVolumeSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_logical_volume_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_LOGICAL_VOLUME_SKELETON, UDisksLogicalVolumeSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 15);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[4], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[5], G_TYPE_DOUBLE);
  g_value_init (&skeleton->priv->properties[6], G_TYPE_DOUBLE);
  g_value_init (&skeleton->priv->properties[7], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[8], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[9], G_TYPE_VARIANT);
  g_value_init (&skeleton->priv->properties[10], G_TYPE_DOUBLE);
  g_value_init (&skeleton->priv->properties[11], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[12], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[13], G_TYPE_VARIANT);
  g_value_init (&skeleton->priv->properties[14], G_TYPE_STRING);
}

static const gchar *
udisks_logical_volume_skeleton_get_volume_group (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_logical_volume_skeleton_get_name (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_logical_volume_skeleton_get_active (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_logical_volume_skeleton_get_uuid (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_logical_volume_skeleton_get_size (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[4]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gdouble 
udisks_logical_volume_skeleton_get_data_allocated_ratio (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  gdouble value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_double (&(skeleton->priv->properties[5]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gdouble 
udisks_logical_volume_skeleton_get_metadata_allocated_ratio (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  gdouble value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_double (&(skeleton->priv->properties[6]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_logical_volume_skeleton_get_type_ (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[7]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_logical_volume_skeleton_get_layout (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[8]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static GVariant *
udisks_logical_volume_skeleton_get_structure (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  GVariant *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_variant (&(skeleton->priv->properties[9]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gdouble 
udisks_logical_volume_skeleton_get_sync_ratio (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  gdouble value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_double (&(skeleton->priv->properties[10]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_logical_volume_skeleton_get_thin_pool (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[11]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_logical_volume_skeleton_get_origin (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[12]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static GVariant *
udisks_logical_volume_skeleton_get_child_configuration (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  GVariant *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_variant (&(skeleton->priv->properties[13]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_logical_volume_skeleton_get_block_device (UDisksLogicalVolume *object)
{
  UDisksLogicalVolumeSkeleton *skeleton = UDISKS_LOGICAL_VOLUME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[14]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_logical_volume_skeleton_class_init (UDisksLogicalVolumeSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_logical_volume_skeleton_finalize;
  gobject_class->get_property = udisks_logical_volume_skeleton_get_property;
  gobject_class->set_property = udisks_logical_volume_skeleton_set_property;
  gobject_class->notify       = udisks_logical_volume_skeleton_notify;


  udisks_logical_volume_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_logical_volume_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_logical_volume_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_logical_volume_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_logical_volume_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksLogicalVolumeSkeletonPrivate));
#endif
}

static void
udisks_logical_volume_skeleton_iface_init (UDisksLogicalVolumeIface *iface)
{
  iface->get_volume_group = udisks_logical_volume_skeleton_get_volume_group;
  iface->get_name = udisks_logical_volume_skeleton_get_name;
  iface->get_active = udisks_logical_volume_skeleton_get_active;
  iface->get_uuid = udisks_logical_volume_skeleton_get_uuid;
  iface->get_size = udisks_logical_volume_skeleton_get_size;
  iface->get_data_allocated_ratio = udisks_logical_volume_skeleton_get_data_allocated_ratio;
  iface->get_metadata_allocated_ratio = udisks_logical_volume_skeleton_get_metadata_allocated_ratio;
  iface->get_type_ = udisks_logical_volume_skeleton_get_type_;
  iface->get_layout = udisks_logical_volume_skeleton_get_layout;
  iface->get_structure = udisks_logical_volume_skeleton_get_structure;
  iface->get_sync_ratio = udisks_logical_volume_skeleton_get_sync_ratio;
  iface->get_thin_pool = udisks_logical_volume_skeleton_get_thin_pool;
  iface->get_origin = udisks_logical_volume_skeleton_get_origin;
  iface->get_child_configuration = udisks_logical_volume_skeleton_get_child_configuration;
  iface->get_block_device = udisks_logical_volume_skeleton_get_block_device;
}

/**
 * udisks_logical_volume_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-LogicalVolume.top_of_page">org.freedesktop.UDisks2.LogicalVolume</link>.
 *
 * Returns: (transfer full) (type UDisksLogicalVolumeSkeleton): The skeleton object.
 *
 * Since: 2.0.0
 */
UDisksLogicalVolume *
udisks_logical_volume_skeleton_new (void)
{
  return UDISKS_LOGICAL_VOLUME (g_object_new (UDISKS_TYPE_LOGICAL_VOLUME_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for interface org.freedesktop.UDisks2.VDOVolume
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksVDOVolume
 * @title: UDisksVDOVolume
 * @short_description: Generated C code for the org.freedesktop.UDisks2.VDOVolume D-Bus interface
 *
 * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks2-VDOVolume.top_of_page">org.freedesktop.UDisks2.VDOVolume</link> D-Bus interface in C.
 */

/* ---- Introspection data for org.freedesktop.UDisks2.VDOVolume ---- */

static const _ExtendedGDBusArgInfo _udisks_vdo_volume_method_info_enable_compression_IN_ARG_enable =
{
  {
    -1,
    (gchar *) "enable",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_vdo_volume_method_info_enable_compression_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_vdo_volume_method_info_enable_compression_IN_ARG_pointers[] =
{
  &_udisks_vdo_volume_method_info_enable_compression_IN_ARG_enable.parent_struct,
  &_udisks_vdo_volume_method_info_enable_compression_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_vdo_volume_method_info_enable_compression =
{
  {
    -1,
    (gchar *) "EnableCompression",
    (GDBusArgInfo **) &_udisks_vdo_volume_method_info_enable_compression_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-enable-compression",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_vdo_volume_method_info_enable_deduplication_IN_ARG_enable =
{
  {
    -1,
    (gchar *) "enable",
    (gchar *) "b",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_vdo_volume_method_info_enable_deduplication_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_vdo_volume_method_info_enable_deduplication_IN_ARG_pointers[] =
{
  &_udisks_vdo_volume_method_info_enable_deduplication_IN_ARG_enable.parent_struct,
  &_udisks_vdo_volume_method_info_enable_deduplication_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_vdo_volume_method_info_enable_deduplication =
{
  {
    -1,
    (gchar *) "EnableDeduplication",
    (GDBusArgInfo **) &_udisks_vdo_volume_method_info_enable_deduplication_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-enable-deduplication",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_vdo_volume_method_info_resize_logical_IN_ARG_size =
{
  {
    -1,
    (gchar *) "size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_vdo_volume_method_info_resize_logical_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_vdo_volume_method_info_resize_logical_IN_ARG_pointers[] =
{
  &_udisks_vdo_volume_method_info_resize_logical_IN_ARG_size.parent_struct,
  &_udisks_vdo_volume_method_info_resize_logical_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_vdo_volume_method_info_resize_logical =
{
  {
    -1,
    (gchar *) "ResizeLogical",
    (GDBusArgInfo **) &_udisks_vdo_volume_method_info_resize_logical_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-resize-logical",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_vdo_volume_method_info_resize_physical_IN_ARG_size =
{
  {
    -1,
    (gchar *) "size",
    (gchar *) "t",
    NULL
  },
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_vdo_volume_method_info_resize_physical_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_vdo_volume_method_info_resize_physical_IN_ARG_pointers[] =
{
  &_udisks_vdo_volume_method_info_resize_physical_IN_ARG_size.parent_struct,
  &_udisks_vdo_volume_method_info_resize_physical_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_vdo_volume_method_info_resize_physical =
{
  {
    -1,
    (gchar *) "ResizePhysical",
    (GDBusArgInfo **) &_udisks_vdo_volume_method_info_resize_physical_IN_ARG_pointers,
    NULL,
    NULL
  },
  "handle-resize-physical",
  FALSE
};

static const _ExtendedGDBusArgInfo _udisks_vdo_volume_method_info_get_statistics_IN_ARG_options =
{
  {
    -1,
    (gchar *) "options",
    (gchar *) "a{sv}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_vdo_volume_method_info_get_statistics_IN_ARG_pointers[] =
{
  &_udisks_vdo_volume_method_info_get_statistics_IN_ARG_options.parent_struct,
  NULL
};

static const _ExtendedGDBusArgInfo _udisks_vdo_volume_method_info_get_statistics_OUT_ARG_stats =
{
  {
    -1,
    (gchar *) "stats",
    (gchar *) "a{ss}",
    NULL
  },
  FALSE
};

static const GDBusArgInfo * const _udisks_vdo_volume_method_info_get_statistics_OUT_ARG_pointers[] =
{
  &_udisks_vdo_volume_method_info_get_statistics_OUT_ARG_stats.parent_struct,
  NULL
};

static const _ExtendedGDBusMethodInfo _udisks_vdo_volume_method_info_get_statistics =
{
  {
    -1,
    (gchar *) "GetStatistics",
    (GDBusArgInfo **) &_udisks_vdo_volume_method_info_get_statistics_IN_ARG_pointers,
    (GDBusArgInfo **) &_udisks_vdo_volume_method_info_get_statistics_OUT_ARG_pointers,
    NULL
  },
  "handle-get-statistics",
  FALSE
};

static const GDBusMethodInfo * const _udisks_vdo_volume_method_info_pointers[] =
{
  &_udisks_vdo_volume_method_info_enable_compression.parent_struct,
  &_udisks_vdo_volume_method_info_enable_deduplication.parent_struct,
  &_udisks_vdo_volume_method_info_resize_logical.parent_struct,
  &_udisks_vdo_volume_method_info_resize_physical.parent_struct,
  &_udisks_vdo_volume_method_info_get_statistics.parent_struct,
  NULL
};

static const _ExtendedGDBusPropertyInfo _udisks_vdo_volume_property_info_vdo_pool =
{
  {
    -1,
    (gchar *) "VDOPool",
    (gchar *) "o",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "vdo-pool",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_vdo_volume_property_info_operating_mode =
{
  {
    -1,
    (gchar *) "OperatingMode",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "operating-mode",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_vdo_volume_property_info_compression_state =
{
  {
    -1,
    (gchar *) "CompressionState",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "compression-state",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_vdo_volume_property_info_index_state =
{
  {
    -1,
    (gchar *) "IndexState",
    (gchar *) "s",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "index-state",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_vdo_volume_property_info_used_size =
{
  {
    -1,
    (gchar *) "UsedSize",
    (gchar *) "t",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "used-size",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_vdo_volume_property_info_compression =
{
  {
    -1,
    (gchar *) "Compression",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "compression",
  FALSE,
  TRUE
};

static const _ExtendedGDBusPropertyInfo _udisks_vdo_volume_property_info_deduplication =
{
  {
    -1,
    (gchar *) "Deduplication",
    (gchar *) "b",
    G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
    NULL
  },
  "deduplication",
  FALSE,
  TRUE
};

static const GDBusPropertyInfo * const _udisks_vdo_volume_property_info_pointers[] =
{
  &_udisks_vdo_volume_property_info_vdo_pool.parent_struct,
  &_udisks_vdo_volume_property_info_operating_mode.parent_struct,
  &_udisks_vdo_volume_property_info_compression_state.parent_struct,
  &_udisks_vdo_volume_property_info_index_state.parent_struct,
  &_udisks_vdo_volume_property_info_used_size.parent_struct,
  &_udisks_vdo_volume_property_info_compression.parent_struct,
  &_udisks_vdo_volume_property_info_deduplication.parent_struct,
  NULL
};

static const _ExtendedGDBusInterfaceInfo _udisks_vdo_volume_interface_info =
{
  {
    -1,
    (gchar *) "org.freedesktop.UDisks2.VDOVolume",
    (GDBusMethodInfo **) &_udisks_vdo_volume_method_info_pointers,
    NULL,
    (GDBusPropertyInfo **) &_udisks_vdo_volume_property_info_pointers,
    NULL
  },
  "vdo-volume",
};


/**
 * udisks_vdo_volume_interface_info:
 *
 * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks2-VDOVolume.top_of_page">org.freedesktop.UDisks2.VDOVolume</link> D-Bus interface.
 *
 * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
 *
 * Since: 2.9.0
 */
GDBusInterfaceInfo *
udisks_vdo_volume_interface_info (void)
{
  return (GDBusInterfaceInfo *) &_udisks_vdo_volume_interface_info.parent_struct;
}

/**
 * udisks_vdo_volume_override_properties:
 * @klass: The class structure for a #GObject derived class.
 * @property_id_begin: The property id to assign to the first overridden property.
 *
 * Overrides all #GObject properties in the #UDisksVDOVolume interface for a concrete class.
 * The properties are overridden in the order they are defined.
 *
 * Returns: The last property id.
 *
 * Since: 2.9.0
 */
guint
udisks_vdo_volume_override_properties (GObjectClass *klass, guint property_id_begin)
{
  g_object_class_override_property (klass, property_id_begin++, "vdo-pool");
  g_object_class_override_property (klass, property_id_begin++, "operating-mode");
  g_object_class_override_property (klass, property_id_begin++, "compression-state");
  g_object_class_override_property (klass, property_id_begin++, "index-state");
  g_object_class_override_property (klass, property_id_begin++, "used-size");
  g_object_class_override_property (klass, property_id_begin++, "compression");
  g_object_class_override_property (klass, property_id_begin++, "deduplication");
  return property_id_begin - 1;
}


inline static void
udisks_vdo_volume_method_marshal_enable_compression (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOOLEAN_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_vdo_volume_method_marshal_enable_deduplication (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_BOOLEAN_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_vdo_volume_method_marshal_resize_logical (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT64_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_vdo_volume_method_marshal_resize_physical (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_UINT64_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}

inline static void
udisks_vdo_volume_method_marshal_get_statistics (
    GClosure     *closure,
    GValue       *return_value,
    unsigned int  n_param_values,
    const GValue *param_values,
    void         *invocation_hint,
    void         *marshal_data)
{
  _g_dbus_codegen_marshal_BOOLEAN__OBJECT_VARIANT (closure,
    return_value, n_param_values, param_values, invocation_hint, marshal_data);
}


/**
 * UDisksVDOVolume:
 *
 * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VDOVolume.top_of_page">org.freedesktop.UDisks2.VDOVolume</link>.
 *
 * Since: 2.9.0
 */

/**
 * UDisksVDOVolumeIface:
 * @parent_iface: The parent interface.
 * @handle_enable_compression: Handler for the #UDisksVDOVolume::handle-enable-compression signal.
 * @handle_enable_deduplication: Handler for the #UDisksVDOVolume::handle-enable-deduplication signal.
 * @handle_get_statistics: Handler for the #UDisksVDOVolume::handle-get-statistics signal.
 * @handle_resize_logical: Handler for the #UDisksVDOVolume::handle-resize-logical signal.
 * @handle_resize_physical: Handler for the #UDisksVDOVolume::handle-resize-physical signal.
 * @get_compression: Getter for the #UDisksVDOVolume:compression property.
 * @get_compression_state: Getter for the #UDisksVDOVolume:compression-state property.
 * @get_deduplication: Getter for the #UDisksVDOVolume:deduplication property.
 * @get_index_state: Getter for the #UDisksVDOVolume:index-state property.
 * @get_operating_mode: Getter for the #UDisksVDOVolume:operating-mode property.
 * @get_used_size: Getter for the #UDisksVDOVolume:used-size property.
 * @get_vdo_pool: Getter for the #UDisksVDOVolume:vdo-pool property.
 *
 * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VDOVolume.top_of_page">org.freedesktop.UDisks2.VDOVolume</link>.
 *
 * Since: 2.9.0
 */

typedef UDisksVDOVolumeIface UDisksVDOVolumeInterface;
G_DEFINE_INTERFACE (UDisksVDOVolume, udisks_vdo_volume, G_TYPE_OBJECT)

static void
udisks_vdo_volume_default_init (UDisksVDOVolumeIface *iface)
{
  /* GObject signals for incoming D-Bus method calls: */
  /**
   * UDisksVDOVolume::handle-enable-compression:
   * @object: A #UDisksVDOVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_enable: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.EnableCompression">EnableCompression()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_vdo_volume_complete_enable_compression() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.9.0
   */
  g_signal_new ("handle-enable-compression",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVDOVolumeIface, handle_enable_compression),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_vdo_volume_method_marshal_enable_compression,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_BOOLEAN, G_TYPE_VARIANT);

  /**
   * UDisksVDOVolume::handle-enable-deduplication:
   * @object: A #UDisksVDOVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_enable: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.EnableDeduplication">EnableDeduplication()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_vdo_volume_complete_enable_deduplication() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.9.0
   */
  g_signal_new ("handle-enable-deduplication",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVDOVolumeIface, handle_enable_deduplication),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_vdo_volume_method_marshal_enable_deduplication,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_BOOLEAN, G_TYPE_VARIANT);

  /**
   * UDisksVDOVolume::handle-resize-logical:
   * @object: A #UDisksVDOVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_size: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.ResizeLogical">ResizeLogical()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_vdo_volume_complete_resize_logical() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.9.0
   */
  g_signal_new ("handle-resize-logical",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVDOVolumeIface, handle_resize_logical),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_vdo_volume_method_marshal_resize_logical,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT64, G_TYPE_VARIANT);

  /**
   * UDisksVDOVolume::handle-resize-physical:
   * @object: A #UDisksVDOVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_size: Argument passed by remote caller.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.ResizePhysical">ResizePhysical()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_vdo_volume_complete_resize_physical() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.9.0
   */
  g_signal_new ("handle-resize-physical",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVDOVolumeIface, handle_resize_physical),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_vdo_volume_method_marshal_resize_physical,
    G_TYPE_BOOLEAN,
    3,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_UINT64, G_TYPE_VARIANT);

  /**
   * UDisksVDOVolume::handle-get-statistics:
   * @object: A #UDisksVDOVolume.
   * @invocation: A #GDBusMethodInvocation.
   * @arg_options: Argument passed by remote caller.
   *
   * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.GetStatistics">GetStatistics()</link> D-Bus method.
   *
   * If a signal handler returns %TRUE, it means the signal handler will handle the invocation (e.g. take a reference to @invocation and eventually call udisks_vdo_volume_complete_get_statistics() or e.g. g_dbus_method_invocation_return_error() on it) and no other signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
   *
   * Returns: %G_DBUS_METHOD_INVOCATION_HANDLED or %TRUE if the invocation was handled, %G_DBUS_METHOD_INVOCATION_UNHANDLED or %FALSE to let other signal handlers run.
   *
   * Since: 2.9.0
   */
  g_signal_new ("handle-get-statistics",
    G_TYPE_FROM_INTERFACE (iface),
    G_SIGNAL_RUN_LAST,
    G_STRUCT_OFFSET (UDisksVDOVolumeIface, handle_get_statistics),
    g_signal_accumulator_true_handled,
    NULL,
      udisks_vdo_volume_method_marshal_get_statistics,
    G_TYPE_BOOLEAN,
    2,
    G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_VARIANT);

  /* GObject properties for D-Bus properties: */
  /**
   * UDisksVDOVolume:vdo-pool:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.VDOPool">"VDOPool"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.9.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("vdo-pool", "VDOPool", "VDOPool", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksVDOVolume:operating-mode:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.OperatingMode">"OperatingMode"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.9.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("operating-mode", "OperatingMode", "OperatingMode", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksVDOVolume:compression-state:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.CompressionState">"CompressionState"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.9.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("compression-state", "CompressionState", "CompressionState", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksVDOVolume:index-state:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.IndexState">"IndexState"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.9.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_string ("index-state", "IndexState", "IndexState", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksVDOVolume:used-size:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.UsedSize">"UsedSize"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.9.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_uint64 ("used-size", "UsedSize", "UsedSize", 0, G_MAXUINT64, 0, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksVDOVolume:compression:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.Compression">"Compression"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.9.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("compression", "Compression", "Compression", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
  /**
   * UDisksVDOVolume:deduplication:
   *
   * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.Deduplication">"Deduplication"</link>.
   *
   * Since the D-Bus property for this #GObject property is readable but not writable, it is meaningful to read from it on both the client- and service-side. It is only meaningful, however, to write to it on the service-side.
   *
   * Since: 2.9.0
   */
  g_object_interface_install_property (iface,
    g_param_spec_boolean ("deduplication", "Deduplication", "Deduplication", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
}

/**
 * udisks_vdo_volume_get_vdo_pool: (skip)
 * @object: A #UDisksVDOVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.VDOPool">"VDOPool"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_vdo_volume_dup_vdo_pool() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.9.0
 */
const gchar *
udisks_vdo_volume_get_vdo_pool (UDisksVDOVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_VDO_VOLUME (object), NULL);

  return UDISKS_VDO_VOLUME_GET_IFACE (object)->get_vdo_pool (object);
}

/**
 * udisks_vdo_volume_dup_vdo_pool: (skip)
 * @object: A #UDisksVDOVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.VDOPool">"VDOPool"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.9.0
 */
gchar *
udisks_vdo_volume_dup_vdo_pool (UDisksVDOVolume *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "vdo-pool", &value, NULL);
  return value;
}

/**
 * udisks_vdo_volume_set_vdo_pool: (skip)
 * @object: A #UDisksVDOVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.VDOPool">"VDOPool"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_set_vdo_pool (UDisksVDOVolume *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "vdo-pool", value, NULL);
}

/**
 * udisks_vdo_volume_get_operating_mode: (skip)
 * @object: A #UDisksVDOVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.OperatingMode">"OperatingMode"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_vdo_volume_dup_operating_mode() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.9.0
 */
const gchar *
udisks_vdo_volume_get_operating_mode (UDisksVDOVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_VDO_VOLUME (object), NULL);

  return UDISKS_VDO_VOLUME_GET_IFACE (object)->get_operating_mode (object);
}

/**
 * udisks_vdo_volume_dup_operating_mode: (skip)
 * @object: A #UDisksVDOVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.OperatingMode">"OperatingMode"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.9.0
 */
gchar *
udisks_vdo_volume_dup_operating_mode (UDisksVDOVolume *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "operating-mode", &value, NULL);
  return value;
}

/**
 * udisks_vdo_volume_set_operating_mode: (skip)
 * @object: A #UDisksVDOVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.OperatingMode">"OperatingMode"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_set_operating_mode (UDisksVDOVolume *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "operating-mode", value, NULL);
}

/**
 * udisks_vdo_volume_get_compression_state: (skip)
 * @object: A #UDisksVDOVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.CompressionState">"CompressionState"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_vdo_volume_dup_compression_state() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.9.0
 */
const gchar *
udisks_vdo_volume_get_compression_state (UDisksVDOVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_VDO_VOLUME (object), NULL);

  return UDISKS_VDO_VOLUME_GET_IFACE (object)->get_compression_state (object);
}

/**
 * udisks_vdo_volume_dup_compression_state: (skip)
 * @object: A #UDisksVDOVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.CompressionState">"CompressionState"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.9.0
 */
gchar *
udisks_vdo_volume_dup_compression_state (UDisksVDOVolume *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "compression-state", &value, NULL);
  return value;
}

/**
 * udisks_vdo_volume_set_compression_state: (skip)
 * @object: A #UDisksVDOVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.CompressionState">"CompressionState"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_set_compression_state (UDisksVDOVolume *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "compression-state", value, NULL);
}

/**
 * udisks_vdo_volume_get_index_state: (skip)
 * @object: A #UDisksVDOVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.IndexState">"IndexState"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * The returned value is only valid until the property changes so on the client-side it is only safe to use this function on the thread where @object was constructed. Use udisks_vdo_volume_dup_index_state() if on another thread.
 *
 * Returns: (transfer none) (nullable): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
 *
 * Since: 2.9.0
 */
const gchar *
udisks_vdo_volume_get_index_state (UDisksVDOVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_VDO_VOLUME (object), NULL);

  return UDISKS_VDO_VOLUME_GET_IFACE (object)->get_index_state (object);
}

/**
 * udisks_vdo_volume_dup_index_state: (skip)
 * @object: A #UDisksVDOVolume.
 *
 * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.IndexState">"IndexState"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: (transfer full) (nullable): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
 *
 * Since: 2.9.0
 */
gchar *
udisks_vdo_volume_dup_index_state (UDisksVDOVolume *object)
{
  gchar *value;
  g_object_get (G_OBJECT (object), "index-state", &value, NULL);
  return value;
}

/**
 * udisks_vdo_volume_set_index_state: (skip)
 * @object: A #UDisksVDOVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.IndexState">"IndexState"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_set_index_state (UDisksVDOVolume *object, const gchar *value)
{
  g_object_set (G_OBJECT (object), "index-state", value, NULL);
}

/**
 * udisks_vdo_volume_get_used_size: (skip)
 * @object: A #UDisksVDOVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.UsedSize">"UsedSize"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.9.0
 */
guint64 
udisks_vdo_volume_get_used_size (UDisksVDOVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_VDO_VOLUME (object), 0);

  return UDISKS_VDO_VOLUME_GET_IFACE (object)->get_used_size (object);
}

/**
 * udisks_vdo_volume_set_used_size: (skip)
 * @object: A #UDisksVDOVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.UsedSize">"UsedSize"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_set_used_size (UDisksVDOVolume *object, guint64 value)
{
  g_object_set (G_OBJECT (object), "used-size", value, NULL);
}

/**
 * udisks_vdo_volume_get_compression: (skip)
 * @object: A #UDisksVDOVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.Compression">"Compression"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.9.0
 */
gboolean 
udisks_vdo_volume_get_compression (UDisksVDOVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_VDO_VOLUME (object), FALSE);

  return UDISKS_VDO_VOLUME_GET_IFACE (object)->get_compression (object);
}

/**
 * udisks_vdo_volume_set_compression: (skip)
 * @object: A #UDisksVDOVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.Compression">"Compression"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_set_compression (UDisksVDOVolume *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "compression", value, NULL);
}

/**
 * udisks_vdo_volume_get_deduplication: (skip)
 * @object: A #UDisksVDOVolume.
 *
 * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.Deduplication">"Deduplication"</link> D-Bus property.
 *
 * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
 *
 * Returns: The property value.
 *
 * Since: 2.9.0
 */
gboolean 
udisks_vdo_volume_get_deduplication (UDisksVDOVolume *object)
{
  g_return_val_if_fail (UDISKS_IS_VDO_VOLUME (object), FALSE);

  return UDISKS_VDO_VOLUME_GET_IFACE (object)->get_deduplication (object);
}

/**
 * udisks_vdo_volume_set_deduplication: (skip)
 * @object: A #UDisksVDOVolume.
 * @value: The value to set.
 *
 * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks2-VDOVolume.Deduplication">"Deduplication"</link> D-Bus property to @value.
 *
 * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_set_deduplication (UDisksVDOVolume *object, gboolean value)
{
  g_object_set (G_OBJECT (object), "deduplication", value, NULL);
}

/**
 * udisks_vdo_volume_call_enable_compression:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @arg_enable: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.EnableCompression">EnableCompression()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_vdo_volume_call_enable_compression_finish() to get the result of the operation.
 *
 * See udisks_vdo_volume_call_enable_compression_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_call_enable_compression (
    UDisksVDOVolume *proxy,
    gboolean arg_enable,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "EnableCompression",
    g_variant_new ("(b@a{sv})",
                   arg_enable,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_vdo_volume_call_enable_compression_finish:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_vdo_volume_call_enable_compression().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_vdo_volume_call_enable_compression().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.9.0
 */
gboolean
udisks_vdo_volume_call_enable_compression_finish (
    UDisksVDOVolume *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_vdo_volume_call_enable_compression_sync:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @arg_enable: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.EnableCompression">EnableCompression()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_vdo_volume_call_enable_compression() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.9.0
 */
gboolean
udisks_vdo_volume_call_enable_compression_sync (
    UDisksVDOVolume *proxy,
    gboolean arg_enable,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "EnableCompression",
    g_variant_new ("(b@a{sv})",
                   arg_enable,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_vdo_volume_call_enable_deduplication:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @arg_enable: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.EnableDeduplication">EnableDeduplication()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_vdo_volume_call_enable_deduplication_finish() to get the result of the operation.
 *
 * See udisks_vdo_volume_call_enable_deduplication_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_call_enable_deduplication (
    UDisksVDOVolume *proxy,
    gboolean arg_enable,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "EnableDeduplication",
    g_variant_new ("(b@a{sv})",
                   arg_enable,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_vdo_volume_call_enable_deduplication_finish:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_vdo_volume_call_enable_deduplication().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_vdo_volume_call_enable_deduplication().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.9.0
 */
gboolean
udisks_vdo_volume_call_enable_deduplication_finish (
    UDisksVDOVolume *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_vdo_volume_call_enable_deduplication_sync:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @arg_enable: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.EnableDeduplication">EnableDeduplication()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_vdo_volume_call_enable_deduplication() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.9.0
 */
gboolean
udisks_vdo_volume_call_enable_deduplication_sync (
    UDisksVDOVolume *proxy,
    gboolean arg_enable,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "EnableDeduplication",
    g_variant_new ("(b@a{sv})",
                   arg_enable,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_vdo_volume_call_resize_logical:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.ResizeLogical">ResizeLogical()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_vdo_volume_call_resize_logical_finish() to get the result of the operation.
 *
 * See udisks_vdo_volume_call_resize_logical_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_call_resize_logical (
    UDisksVDOVolume *proxy,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "ResizeLogical",
    g_variant_new ("(t@a{sv})",
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_vdo_volume_call_resize_logical_finish:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_vdo_volume_call_resize_logical().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_vdo_volume_call_resize_logical().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.9.0
 */
gboolean
udisks_vdo_volume_call_resize_logical_finish (
    UDisksVDOVolume *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_vdo_volume_call_resize_logical_sync:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.ResizeLogical">ResizeLogical()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_vdo_volume_call_resize_logical() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.9.0
 */
gboolean
udisks_vdo_volume_call_resize_logical_sync (
    UDisksVDOVolume *proxy,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "ResizeLogical",
    g_variant_new ("(t@a{sv})",
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_vdo_volume_call_resize_physical:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.ResizePhysical">ResizePhysical()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_vdo_volume_call_resize_physical_finish() to get the result of the operation.
 *
 * See udisks_vdo_volume_call_resize_physical_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_call_resize_physical (
    UDisksVDOVolume *proxy,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "ResizePhysical",
    g_variant_new ("(t@a{sv})",
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_vdo_volume_call_resize_physical_finish:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_vdo_volume_call_resize_physical().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_vdo_volume_call_resize_physical().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.9.0
 */
gboolean
udisks_vdo_volume_call_resize_physical_finish (
    UDisksVDOVolume *proxy,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_vdo_volume_call_resize_physical_sync:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @arg_size: Argument to pass with the method invocation.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.ResizePhysical">ResizePhysical()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_vdo_volume_call_resize_physical() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.9.0
 */
gboolean
udisks_vdo_volume_call_resize_physical_sync (
    UDisksVDOVolume *proxy,
    guint64 arg_size,
    GVariant *arg_options,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "ResizePhysical",
    g_variant_new ("(t@a{sv})",
                   arg_size,
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "()");
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_vdo_volume_call_get_statistics:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.GetStatistics">GetStatistics()</link> D-Bus method on @proxy.
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_vdo_volume_call_get_statistics_finish() to get the result of the operation.
 *
 * See udisks_vdo_volume_call_get_statistics_sync() for the synchronous, blocking version of this method.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_call_get_statistics (
    UDisksVDOVolume *proxy,
    GVariant *arg_options,
    GCancellable *cancellable,
    GAsyncReadyCallback callback,
    gpointer user_data)
{
  g_dbus_proxy_call (G_DBUS_PROXY (proxy),
    "GetStatistics",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    callback,
    user_data);
}

/**
 * udisks_vdo_volume_call_get_statistics_finish:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @out_stats: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_vdo_volume_call_get_statistics().
 * @error: Return location for error or %NULL.
 *
 * Finishes an operation started with udisks_vdo_volume_call_get_statistics().
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.9.0
 */
gboolean
udisks_vdo_volume_call_get_statistics_finish (
    UDisksVDOVolume *proxy,
    GVariant ** out_stats,
    GAsyncResult *res,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@a{ss})",
                 out_stats);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_vdo_volume_call_get_statistics_sync:
 * @proxy: A #UDisksVDOVolumeProxy.
 * @arg_options: Argument to pass with the method invocation.
 * @out_stats: (out) (optional): Return location for return parameter or %NULL to ignore.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL.
 *
 * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.GetStatistics">GetStatistics()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
 *
 * See udisks_vdo_volume_call_get_statistics() for the asynchronous version of this method.
 *
 * Returns: (skip): %TRUE if the call succeeded, %FALSE if @error is set.
 *
 * Since: 2.9.0
 */
gboolean
udisks_vdo_volume_call_get_statistics_sync (
    UDisksVDOVolume *proxy,
    GVariant *arg_options,
    GVariant ** out_stats,
    GCancellable *cancellable,
    GError **error)
{
  GVariant *_ret;
  _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
    "GetStatistics",
    g_variant_new ("(@a{sv})",
                   arg_options),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    cancellable,
    error);
  if (_ret == NULL)
    goto _out;
  g_variant_get (_ret,
                 "(@a{ss})",
                 out_stats);
  g_variant_unref (_ret);
_out:
  return _ret != NULL;
}

/**
 * udisks_vdo_volume_complete_enable_compression:
 * @object: A #UDisksVDOVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.EnableCompression">EnableCompression()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_complete_enable_compression (
    UDisksVDOVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_vdo_volume_complete_enable_deduplication:
 * @object: A #UDisksVDOVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.EnableDeduplication">EnableDeduplication()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_complete_enable_deduplication (
    UDisksVDOVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_vdo_volume_complete_resize_logical:
 * @object: A #UDisksVDOVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.ResizeLogical">ResizeLogical()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_complete_resize_logical (
    UDisksVDOVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_vdo_volume_complete_resize_physical:
 * @object: A #UDisksVDOVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.ResizePhysical">ResizePhysical()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_complete_resize_physical (
    UDisksVDOVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("()"));
}

/**
 * udisks_vdo_volume_complete_get_statistics:
 * @object: A #UDisksVDOVolume.
 * @invocation: (transfer full): A #GDBusMethodInvocation.
 * @stats: Parameter to return.
 *
 * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks2-VDOVolume.GetStatistics">GetStatistics()</link> D-Bus method. If you instead want to finish handling an invocation by returning an error, use g_dbus_method_invocation_return_error() or similar.
 *
 * This method will free @invocation, you cannot use it afterwards.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_complete_get_statistics (
    UDisksVDOVolume *object G_GNUC_UNUSED,
    GDBusMethodInvocation *invocation,
    GVariant *stats)
{
  g_dbus_method_invocation_return_value (invocation,
    g_variant_new ("(@a{ss})",
                   stats));
}

/* ------------------------------------------------------------------------ */

/**
 * UDisksVDOVolumeProxy:
 *
 * The #UDisksVDOVolumeProxy structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.9.0
 */

/**
 * UDisksVDOVolumeProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksVDOVolumeProxy.
 *
 * Since: 2.9.0
 */

struct _UDisksVDOVolumeProxyPrivate
{
  GData *qdata;
};

static void udisks_vdo_volume_proxy_iface_init (UDisksVDOVolumeIface *iface);

#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksVDOVolumeProxy, udisks_vdo_volume_proxy, G_TYPE_DBUS_PROXY,
                         G_ADD_PRIVATE (UDisksVDOVolumeProxy)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_VDO_VOLUME, udisks_vdo_volume_proxy_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksVDOVolumeProxy, udisks_vdo_volume_proxy, G_TYPE_DBUS_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_VDO_VOLUME, udisks_vdo_volume_proxy_iface_init))

#endif
static void
udisks_vdo_volume_proxy_finalize (GObject *object)
{
  UDisksVDOVolumeProxy *proxy = UDISKS_VDO_VOLUME_PROXY (object);
  g_datalist_clear (&proxy->priv->qdata);
  G_OBJECT_CLASS (udisks_vdo_volume_proxy_parent_class)->finalize (object);
}

static void
udisks_vdo_volume_proxy_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 7);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_vdo_volume_property_info_pointers[prop_id - 1];
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
  if (info->use_gvariant)
    {
      g_value_set_variant (value, variant);
    }
  else
    {
      if (variant != NULL)
        g_dbus_gvariant_to_gvalue (variant, value);
    }
  if (variant != NULL)
    g_variant_unref (variant);
}

static void
udisks_vdo_volume_proxy_set_property_cb (GDBusProxy *proxy,
  GAsyncResult *res,
  gpointer      user_data)
{
  const _ExtendedGDBusPropertyInfo *info = user_data;
  GError *error;
  GVariant *_ret;
  error = NULL;
  _ret = g_dbus_proxy_call_finish (proxy, res, &error);
  if (!_ret)
    {
      g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks2.VDOVolume: %s (%s, %d)",
                 info->parent_struct.name, 
                 error->message, g_quark_to_string (error->domain), error->code);
      g_error_free (error);
    }
  else
    {
      g_variant_unref (_ret);
    }
}

static void
udisks_vdo_volume_proxy_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  const _ExtendedGDBusPropertyInfo *info;
  GVariant *variant;
  g_assert (prop_id != 0 && prop_id - 1 < 7);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_vdo_volume_property_info_pointers[prop_id - 1];
  variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
  g_dbus_proxy_call (G_DBUS_PROXY (object),
    "org.freedesktop.DBus.Properties.Set",
    g_variant_new ("(ssv)", "org.freedesktop.UDisks2.VDOVolume", info->parent_struct.name, variant),
    G_DBUS_CALL_FLAGS_NONE,
    -1,
    NULL, (GAsyncReadyCallback) udisks_vdo_volume_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
  g_variant_unref (variant);
}

static void
udisks_vdo_volume_proxy_g_signal (GDBusProxy *proxy,
  const gchar *sender_name G_GNUC_UNUSED,
  const gchar *signal_name,
  GVariant *parameters)
{
  _ExtendedGDBusSignalInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  gsize n;
  guint signal_id;
  info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_udisks_vdo_volume_interface_info.parent_struct, signal_name);
  if (info == NULL)
    return;
  num_params = g_variant_n_children (parameters);
  paramv = g_new0 (GValue, num_params + 1);
  g_value_init (&paramv[0], UDISKS_TYPE_VDO_VOLUME);
  g_value_set_object (&paramv[0], proxy);
  g_variant_iter_init (&iter, parameters);
  n = 1;
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_VDO_VOLUME);
  g_signal_emitv (paramv, signal_id, 0, NULL);
  for (n = 0; n < num_params + 1; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static void
udisks_vdo_volume_proxy_g_properties_changed (GDBusProxy *_proxy,
  GVariant *changed_properties,
  const gchar *const *invalidated_properties)
{
  UDisksVDOVolumeProxy *proxy = UDISKS_VDO_VOLUME_PROXY (_proxy);
  guint n;
  const gchar *key;
  GVariantIter *iter;
  _ExtendedGDBusPropertyInfo *info;
  g_variant_get (changed_properties, "a{sv}", &iter);
  while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_vdo_volume_interface_info.parent_struct, key);
      g_datalist_remove_data (&proxy->priv->qdata, key);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
  g_variant_iter_free (iter);
  for (n = 0; invalidated_properties[n] != NULL; n++)
    {
      info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_vdo_volume_interface_info.parent_struct, invalidated_properties[n]);
      g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
      if (info != NULL)
        g_object_notify (G_OBJECT (proxy), info->hyphen_name);
    }
}

static const gchar *
udisks_vdo_volume_proxy_get_vdo_pool (UDisksVDOVolume *object)
{
  UDisksVDOVolumeProxy *proxy = UDISKS_VDO_VOLUME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "VDOPool");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_vdo_volume_proxy_get_operating_mode (UDisksVDOVolume *object)
{
  UDisksVDOVolumeProxy *proxy = UDISKS_VDO_VOLUME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "OperatingMode");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_vdo_volume_proxy_get_compression_state (UDisksVDOVolume *object)
{
  UDisksVDOVolumeProxy *proxy = UDISKS_VDO_VOLUME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "CompressionState");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static const gchar *
udisks_vdo_volume_proxy_get_index_state (UDisksVDOVolume *object)
{
  UDisksVDOVolumeProxy *proxy = UDISKS_VDO_VOLUME_PROXY (object);
  GVariant *variant;
  const gchar *value = NULL;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "IndexState");
  if (variant != NULL)
    {
      value = g_variant_get_string (variant, NULL);
      g_variant_unref (variant);
    }
  return value;
}

static guint64 
udisks_vdo_volume_proxy_get_used_size (UDisksVDOVolume *object)
{
  UDisksVDOVolumeProxy *proxy = UDISKS_VDO_VOLUME_PROXY (object);
  GVariant *variant;
  guint64 value = 0;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "UsedSize");
  if (variant != NULL)
    {
      value = g_variant_get_uint64 (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_vdo_volume_proxy_get_compression (UDisksVDOVolume *object)
{
  UDisksVDOVolumeProxy *proxy = UDISKS_VDO_VOLUME_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Compression");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static gboolean 
udisks_vdo_volume_proxy_get_deduplication (UDisksVDOVolume *object)
{
  UDisksVDOVolumeProxy *proxy = UDISKS_VDO_VOLUME_PROXY (object);
  GVariant *variant;
  gboolean value = FALSE;
  variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "Deduplication");
  if (variant != NULL)
    {
      value = g_variant_get_boolean (variant);
      g_variant_unref (variant);
    }
  return value;
}

static void
udisks_vdo_volume_proxy_init (UDisksVDOVolumeProxy *proxy)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  proxy->priv = udisks_vdo_volume_proxy_get_instance_private (proxy);
#else
  proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, UDISKS_TYPE_VDO_VOLUME_PROXY, UDisksVDOVolumeProxyPrivate);
#endif

  g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), udisks_vdo_volume_interface_info ());
}

static void
udisks_vdo_volume_proxy_class_init (UDisksVDOVolumeProxyClass *klass)
{
  GObjectClass *gobject_class;
  GDBusProxyClass *proxy_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize     = udisks_vdo_volume_proxy_finalize;
  gobject_class->get_property = udisks_vdo_volume_proxy_get_property;
  gobject_class->set_property = udisks_vdo_volume_proxy_set_property;

  proxy_class = G_DBUS_PROXY_CLASS (klass);
  proxy_class->g_signal = udisks_vdo_volume_proxy_g_signal;
  proxy_class->g_properties_changed = udisks_vdo_volume_proxy_g_properties_changed;

  udisks_vdo_volume_override_properties (gobject_class, 1);

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksVDOVolumeProxyPrivate));
#endif
}

static void
udisks_vdo_volume_proxy_iface_init (UDisksVDOVolumeIface *iface)
{
  iface->get_vdo_pool = udisks_vdo_volume_proxy_get_vdo_pool;
  iface->get_operating_mode = udisks_vdo_volume_proxy_get_operating_mode;
  iface->get_compression_state = udisks_vdo_volume_proxy_get_compression_state;
  iface->get_index_state = udisks_vdo_volume_proxy_get_index_state;
  iface->get_used_size = udisks_vdo_volume_proxy_get_used_size;
  iface->get_compression = udisks_vdo_volume_proxy_get_compression;
  iface->get_deduplication = udisks_vdo_volume_proxy_get_deduplication;
}

/**
 * udisks_vdo_volume_proxy_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VDOVolume.top_of_page">org.freedesktop.UDisks2.VDOVolume</link>. See g_dbus_proxy_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_vdo_volume_proxy_new_finish() to get the result of the operation.
 *
 * See udisks_vdo_volume_proxy_new_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_proxy_new (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_VDO_VOLUME_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.VDOVolume", NULL);
}

/**
 * udisks_vdo_volume_proxy_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_vdo_volume_proxy_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_vdo_volume_proxy_new().
 *
 * Returns: (transfer full) (type UDisksVDOVolumeProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.9.0
 */
UDisksVDOVolume *
udisks_vdo_volume_proxy_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_VDO_VOLUME (ret);
  else
    return NULL;
}

/**
 * udisks_vdo_volume_proxy_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VDOVolume.top_of_page">org.freedesktop.UDisks2.VDOVolume</link>. See g_dbus_proxy_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_vdo_volume_proxy_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksVDOVolumeProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.9.0
 */
UDisksVDOVolume *
udisks_vdo_volume_proxy_new_sync (
    GDBusConnection     *connection,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_VDO_VOLUME_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.VDOVolume", NULL);
  if (ret != NULL)
    return UDISKS_VDO_VOLUME (ret);
  else
    return NULL;
}


/**
 * udisks_vdo_volume_proxy_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_vdo_volume_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_vdo_volume_proxy_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_vdo_volume_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 *
 * Since: 2.9.0
 */
void
udisks_vdo_volume_proxy_new_for_bus (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GAsyncReadyCallback  callback,
    gpointer             user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_VDO_VOLUME_PROXY, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.VDOVolume", NULL);
}

/**
 * udisks_vdo_volume_proxy_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_vdo_volume_proxy_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_vdo_volume_proxy_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksVDOVolumeProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.9.0
 */
UDisksVDOVolume *
udisks_vdo_volume_proxy_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return UDISKS_VDO_VOLUME (ret);
  else
    return NULL;
}

/**
 * udisks_vdo_volume_proxy_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusProxyFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_vdo_volume_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_vdo_volume_proxy_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksVDOVolumeProxy): The constructed proxy object or %NULL if @error is set.
 *
 * Since: 2.9.0
 */
UDisksVDOVolume *
udisks_vdo_volume_proxy_new_for_bus_sync (
    GBusType             bus_type,
    GDBusProxyFlags      flags,
    const gchar         *name,
    const gchar         *object_path,
    GCancellable        *cancellable,
    GError             **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_VDO_VOLUME_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks2.VDOVolume", NULL);
  if (ret != NULL)
    return UDISKS_VDO_VOLUME (ret);
  else
    return NULL;
}


/* ------------------------------------------------------------------------ */

/**
 * UDisksVDOVolumeSkeleton:
 *
 * The #UDisksVDOVolumeSkeleton structure contains only private data and should only be accessed using the provided API.
 *
 * Since: 2.9.0
 */

/**
 * UDisksVDOVolumeSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksVDOVolumeSkeleton.
 *
 * Since: 2.9.0
 */

struct _UDisksVDOVolumeSkeletonPrivate
{
  GValue *properties;
  GList *changed_properties;
  GSource *changed_properties_idle_source;
  GMainContext *context;
  GMutex lock;
};

static void
_udisks_vdo_volume_skeleton_handle_method_call (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name,
  const gchar *method_name,
  GVariant *parameters,
  GDBusMethodInvocation *invocation,
  gpointer user_data)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (user_data);
  _ExtendedGDBusMethodInfo *info;
  GVariantIter iter;
  GVariant *child;
  GValue *paramv;
  gsize num_params;
  guint num_extra;
  gsize n;
  guint signal_id;
  GValue return_value = G_VALUE_INIT;
  info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
  g_assert (info != NULL);
  num_params = g_variant_n_children (parameters);
  num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
  n = 0;
  g_value_init (&paramv[n], UDISKS_TYPE_VDO_VOLUME);
  g_value_set_object (&paramv[n++], skeleton);
  g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
  g_value_set_object (&paramv[n++], invocation);
  if (info->pass_fdlist)
    {
#ifdef G_OS_UNIX
      g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
      g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
#else
      g_assert_not_reached ();
#endif
    }
  g_variant_iter_init (&iter, parameters);
  while ((child = g_variant_iter_next_value (&iter)) != NULL)
    {
      _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
      if (arg_info->use_gvariant)
        {
          g_value_init (&paramv[n], G_TYPE_VARIANT);
          g_value_set_variant (&paramv[n], child);
          n++;
        }
      else
        g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
      g_variant_unref (child);
    }
  signal_id = g_signal_lookup (info->signal_name, UDISKS_TYPE_VDO_VOLUME);
  g_value_init (&return_value, G_TYPE_BOOLEAN);
  g_signal_emitv (paramv, signal_id, 0, &return_value);
  if (!g_value_get_boolean (&return_value))
    g_dbus_method_invocation_return_error (invocation, G_DBUS_ERROR, G_DBUS_ERROR_UNKNOWN_METHOD, "Method %s is not implemented on interface %s", method_name, interface_name);
  g_value_unset (&return_value);
  for (n = 0; n < num_params + num_extra; n++)
    g_value_unset (&paramv[n]);
  g_free (paramv);
}

static GVariant *
_udisks_vdo_volume_skeleton_handle_get_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GError **error,
  gpointer user_data)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  GVariant *ret;
  ret = NULL;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_vdo_volume_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      g_value_init (&value, pspec->value_type);
      g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
      g_value_unset (&value);
    }
  return ret;
}

static gboolean
_udisks_vdo_volume_skeleton_handle_set_property (
  GDBusConnection *connection G_GNUC_UNUSED,
  const gchar *sender G_GNUC_UNUSED,
  const gchar *object_path G_GNUC_UNUSED,
  const gchar *interface_name G_GNUC_UNUSED,
  const gchar *property_name,
  GVariant *variant,
  GError **error,
  gpointer user_data)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (user_data);
  GValue value = G_VALUE_INIT;
  GParamSpec *pspec;
  _ExtendedGDBusPropertyInfo *info;
  gboolean ret;
  ret = FALSE;
  info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_udisks_vdo_volume_interface_info.parent_struct, property_name);
  g_assert (info != NULL);
  pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
  if (pspec == NULL)
    {
      g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
    }
  else
    {
      if (info->use_gvariant)
        g_value_set_variant (&value, variant);
      else
        g_dbus_gvariant_to_gvalue (variant, &value);
      g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
      g_value_unset (&value);
      ret = TRUE;
    }
  return ret;
}

static const GDBusInterfaceVTable _udisks_vdo_volume_skeleton_vtable =
{
  _udisks_vdo_volume_skeleton_handle_method_call,
  _udisks_vdo_volume_skeleton_handle_get_property,
  _udisks_vdo_volume_skeleton_handle_set_property,
  {NULL}
};

static GDBusInterfaceInfo *
udisks_vdo_volume_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return udisks_vdo_volume_interface_info ();
}

static GDBusInterfaceVTable *
udisks_vdo_volume_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
{
  return (GDBusInterfaceVTable *) &_udisks_vdo_volume_skeleton_vtable;
}

static GVariant *
udisks_vdo_volume_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (_skeleton);

  GVariantBuilder builder;
  guint n;
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
#else
  g_variant_builder_init(&builder, G_VARIANT_TYPE ("a{sv}"));
#endif
  if (_udisks_vdo_volume_interface_info.parent_struct.properties == NULL)
    goto out;
  for (n = 0; _udisks_vdo_volume_interface_info.parent_struct.properties[n] != NULL; n++)
    {
      GDBusPropertyInfo *info = _udisks_vdo_volume_interface_info.parent_struct.properties[n];
      if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
        {
          GVariant *value;
          value = _udisks_vdo_volume_skeleton_handle_get_property (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)), NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks2.VDOVolume", info->name, NULL, skeleton);
          if (value != NULL)
            {
              g_variant_take_ref (value);
              g_variant_builder_add (&builder, "{sv}", info->name, value);
              g_variant_unref (value);
            }
        }
    }
out:
  return g_variant_builder_end (&builder);
}

static gboolean _udisks_vdo_volume_emit_changed (gpointer user_data);

static void
udisks_vdo_volume_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (_skeleton);
  gboolean emit_changed = FALSE;

  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties_idle_source != NULL)
    {
      g_source_destroy (skeleton->priv->changed_properties_idle_source);
      skeleton->priv->changed_properties_idle_source = NULL;
      emit_changed = TRUE;
    }
  g_mutex_unlock (&skeleton->priv->lock);

  if (emit_changed)
    _udisks_vdo_volume_emit_changed (skeleton);
}

static void udisks_vdo_volume_skeleton_iface_init (UDisksVDOVolumeIface *iface);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
G_DEFINE_TYPE_WITH_CODE (UDisksVDOVolumeSkeleton, udisks_vdo_volume_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_ADD_PRIVATE (UDisksVDOVolumeSkeleton)
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_VDO_VOLUME, udisks_vdo_volume_skeleton_iface_init))

#else
G_DEFINE_TYPE_WITH_CODE (UDisksVDOVolumeSkeleton, udisks_vdo_volume_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_VDO_VOLUME, udisks_vdo_volume_skeleton_iface_init))

#endif
static void
udisks_vdo_volume_skeleton_finalize (GObject *object)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (object);
  guint n;
  for (n = 0; n < 7; n++)
    g_value_unset (&skeleton->priv->properties[n]);
  g_free (skeleton->priv->properties);
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  /* coverity[missing_lock : SUPPRESS] */
  g_clear_pointer (&skeleton->priv->changed_properties_idle_source, g_source_destroy);
#else
  if (skeleton->priv->changed_properties_idle_source != NULL)
    g_source_destroy (skeleton->priv->changed_properties_idle_source);
skeleton->priv->changed_properties_idle_source = NULL;
#endif
  g_main_context_unref (skeleton->priv->context);
  g_mutex_clear (&skeleton->priv->lock);
  G_OBJECT_CLASS (udisks_vdo_volume_skeleton_parent_class)->finalize (object);
}

static void
udisks_vdo_volume_skeleton_get_property (GObject      *object,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec G_GNUC_UNUSED)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 7);
  g_mutex_lock (&skeleton->priv->lock);
  g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
  g_mutex_unlock (&skeleton->priv->lock);
}

static gboolean
_udisks_vdo_volume_emit_changed (gpointer user_data)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (user_data);
  GList *l;
  GVariantBuilder builder;
  GVariantBuilder invalidated_builder;
  guint num_changes;

  g_mutex_lock (&skeleton->priv->lock);
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_84
  g_variant_builder_init_static (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init_static (&invalidated_builder, G_VARIANT_TYPE ("as"));
#else
  g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
  g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
#endif
  for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
    {
      ChangedProperty *cp = l->data;
      GVariant *variant;
      const GValue *cur_value;

      cur_value = &skeleton->priv->properties[cp->prop_id - 1];
      if (!_g_value_equal (cur_value, &cp->orig_value))
        {
          variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
          g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
          g_variant_unref (variant);
          num_changes++;
        }
    }
  if (num_changes > 0)
    {
      GList *connections, *ll;
      GVariant *signal_variant;
      signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks2.VDOVolume",
                                           &builder, &invalidated_builder));
      connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
      for (ll = connections; ll != NULL; ll = ll->next)
        {
          GDBusConnection *connection = ll->data;

          g_dbus_connection_emit_signal (connection,
                                         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
                                         "org.freedesktop.DBus.Properties",
                                         "PropertiesChanged",
                                         signal_variant,
                                         NULL);
        }
      g_variant_unref (signal_variant);
      g_list_free_full (connections, g_object_unref);
    }
  else
    {
      g_variant_builder_clear (&builder);
      g_variant_builder_clear (&invalidated_builder);
    }
  g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
  skeleton->priv->changed_properties = NULL;
  skeleton->priv->changed_properties_idle_source = NULL;
  g_mutex_unlock (&skeleton->priv->lock);
  return FALSE;
}

static void
_udisks_vdo_volume_schedule_emit_changed (UDisksVDOVolumeSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
{
  ChangedProperty *cp;
  GList *l;
  cp = NULL;
  for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
    {
      ChangedProperty *i_cp = l->data;
      if (i_cp->info == info)
        {
          cp = i_cp;
          break;
        }
    }
  if (cp == NULL)
    {
      cp = g_new0 (ChangedProperty, 1);
      cp->prop_id = prop_id;
      cp->info = info;
      skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
      g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
      g_value_copy (orig_value, &cp->orig_value);
    }
}

static void
udisks_vdo_volume_skeleton_notify (GObject      *object,
  GParamSpec *pspec G_GNUC_UNUSED)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (object);
  g_mutex_lock (&skeleton->priv->lock);
  if (skeleton->priv->changed_properties != NULL &&
      skeleton->priv->changed_properties_idle_source == NULL)
    {
      skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
      g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
      g_source_set_callback (skeleton->priv->changed_properties_idle_source, _udisks_vdo_volume_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
      g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _udisks_vdo_volume_emit_changed");
      g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
      g_source_unref (skeleton->priv->changed_properties_idle_source);
    }
  g_mutex_unlock (&skeleton->priv->lock);
}

static void
udisks_vdo_volume_skeleton_set_property (GObject      *object,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  const _ExtendedGDBusPropertyInfo *info;
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (object);
  g_assert (prop_id != 0 && prop_id - 1 < 7);
  info = (const _ExtendedGDBusPropertyInfo *) _udisks_vdo_volume_property_info_pointers[prop_id - 1];
  g_mutex_lock (&skeleton->priv->lock);
  g_object_freeze_notify (object);
  if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
    {
      if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL &&
          info->emits_changed_signal)
        _udisks_vdo_volume_schedule_emit_changed (skeleton, info, prop_id, &skeleton->priv->properties[prop_id - 1]);
      g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
      g_object_notify_by_pspec (object, pspec);
    }
  g_mutex_unlock (&skeleton->priv->lock);
  g_object_thaw_notify (object);
}

static void
udisks_vdo_volume_skeleton_init (UDisksVDOVolumeSkeleton *skeleton)
{
#if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
  skeleton->priv = udisks_vdo_volume_skeleton_get_instance_private (skeleton);
#else
  skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, UDISKS_TYPE_VDO_VOLUME_SKELETON, UDisksVDOVolumeSkeletonPrivate);
#endif

  g_mutex_init (&skeleton->priv->lock);
  skeleton->priv->context = g_main_context_ref_thread_default ();
  skeleton->priv->properties = g_new0 (GValue, 7);
  g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[1], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[2], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[3], G_TYPE_STRING);
  g_value_init (&skeleton->priv->properties[4], G_TYPE_UINT64);
  g_value_init (&skeleton->priv->properties[5], G_TYPE_BOOLEAN);
  g_value_init (&skeleton->priv->properties[6], G_TYPE_BOOLEAN);
}

static const gchar *
udisks_vdo_volume_skeleton_get_vdo_pool (UDisksVDOVolume *object)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[0]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_vdo_volume_skeleton_get_operating_mode (UDisksVDOVolume *object)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[1]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_vdo_volume_skeleton_get_compression_state (UDisksVDOVolume *object)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[2]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static const gchar *
udisks_vdo_volume_skeleton_get_index_state (UDisksVDOVolume *object)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (object);
  const gchar *value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_string (&(skeleton->priv->properties[3]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static guint64 
udisks_vdo_volume_skeleton_get_used_size (UDisksVDOVolume *object)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (object);
  guint64 value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_uint64 (&(skeleton->priv->properties[4]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_vdo_volume_skeleton_get_compression (UDisksVDOVolume *object)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[5]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static gboolean 
udisks_vdo_volume_skeleton_get_deduplication (UDisksVDOVolume *object)
{
  UDisksVDOVolumeSkeleton *skeleton = UDISKS_VDO_VOLUME_SKELETON (object);
  gboolean value;
  g_mutex_lock (&skeleton->priv->lock);
  value = g_marshal_value_peek_boolean (&(skeleton->priv->properties[6]));
  g_mutex_unlock (&skeleton->priv->lock);
  return value;
}

static void
udisks_vdo_volume_skeleton_class_init (UDisksVDOVolumeSkeletonClass *klass)
{
  GObjectClass *gobject_class;
  GDBusInterfaceSkeletonClass *skeleton_class;

  gobject_class = G_OBJECT_CLASS (klass);
  gobject_class->finalize = udisks_vdo_volume_skeleton_finalize;
  gobject_class->get_property = udisks_vdo_volume_skeleton_get_property;
  gobject_class->set_property = udisks_vdo_volume_skeleton_set_property;
  gobject_class->notify       = udisks_vdo_volume_skeleton_notify;


  udisks_vdo_volume_override_properties (gobject_class, 1);

  skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
  skeleton_class->get_info = udisks_vdo_volume_skeleton_dbus_interface_get_info;
  skeleton_class->get_properties = udisks_vdo_volume_skeleton_dbus_interface_get_properties;
  skeleton_class->flush = udisks_vdo_volume_skeleton_dbus_interface_flush;
  skeleton_class->get_vtable = udisks_vdo_volume_skeleton_dbus_interface_get_vtable;

#if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
  g_type_class_add_private (klass, sizeof (UDisksVDOVolumeSkeletonPrivate));
#endif
}

static void
udisks_vdo_volume_skeleton_iface_init (UDisksVDOVolumeIface *iface)
{
  iface->get_vdo_pool = udisks_vdo_volume_skeleton_get_vdo_pool;
  iface->get_operating_mode = udisks_vdo_volume_skeleton_get_operating_mode;
  iface->get_compression_state = udisks_vdo_volume_skeleton_get_compression_state;
  iface->get_index_state = udisks_vdo_volume_skeleton_get_index_state;
  iface->get_used_size = udisks_vdo_volume_skeleton_get_used_size;
  iface->get_compression = udisks_vdo_volume_skeleton_get_compression;
  iface->get_deduplication = udisks_vdo_volume_skeleton_get_deduplication;
}

/**
 * udisks_vdo_volume_skeleton_new:
 *
 * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VDOVolume.top_of_page">org.freedesktop.UDisks2.VDOVolume</link>.
 *
 * Returns: (transfer full) (type UDisksVDOVolumeSkeleton): The skeleton object.
 *
 * Since: 2.9.0
 */
UDisksVDOVolume *
udisks_vdo_volume_skeleton_new (void)
{
  return UDISKS_VDO_VOLUME (g_object_new (UDISKS_TYPE_VDO_VOLUME_SKELETON, NULL));
}

/* ------------------------------------------------------------------------
 * Code for Object, ObjectProxy and ObjectSkeleton
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksObject
 * @title: UDisksObject
 * @short_description: Specialized GDBusObject types
 *
 * This section contains the #UDisksObject, #UDisksObjectProxy, and #UDisksObjectSkeleton types which make it easier to work with objects implementing generated types for D-Bus interfaces.
 */

/**
 * UDisksObject:
 *
 * The #UDisksObject type is a specialized container of interfaces.
 */

/**
 * UDisksObjectIface:
 * @parent_iface: The parent interface.
 *
 * Virtual table for the #UDisksObject interface.
 */

typedef UDisksObjectIface UDisksObjectInterface;
G_DEFINE_INTERFACE_WITH_CODE (UDisksObject, udisks_object, G_TYPE_OBJECT, g_type_interface_add_prerequisite (g_define_type_id, G_TYPE_DBUS_OBJECT);)

static void
udisks_object_default_init (UDisksObjectIface *iface)
{
  /**
   * UDisksObject:manager:
   *
   * The #UDisksManager instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager.top_of_page">org.freedesktop.UDisks2.Manager</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("manager", "manager", "manager", UDISKS_TYPE_MANAGER, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:manager-nvme:
   *
   * The #UDisksManagerNVMe instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-NVMe.top_of_page">org.freedesktop.UDisks2.Manager.NVMe</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("manager-nvme", "manager-nvme", "manager-nvme", UDISKS_TYPE_MANAGER_NVME, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:drive:
   *
   * The #UDisksDrive instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive.top_of_page">org.freedesktop.UDisks2.Drive</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("drive", "drive", "drive", UDISKS_TYPE_DRIVE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:drive-ata:
   *
   * The #UDisksDriveAta instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive-Ata.top_of_page">org.freedesktop.UDisks2.Drive.Ata</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("drive-ata", "drive-ata", "drive-ata", UDISKS_TYPE_DRIVE_ATA, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:nvme-controller:
   *
   * The #UDisksNVMeController instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Controller.top_of_page">org.freedesktop.UDisks2.NVMe.Controller</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("nvme-controller", "nvme-controller", "nvme-controller", UDISKS_TYPE_NVME_CONTROLLER, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:nvme-namespace:
   *
   * The #UDisksNVMeNamespace instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Namespace.top_of_page">org.freedesktop.UDisks2.NVMe.Namespace</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("nvme-namespace", "nvme-namespace", "nvme-namespace", UDISKS_TYPE_NVME_NAMESPACE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:nvme-fabrics:
   *
   * The #UDisksNVMeFabrics instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Fabrics.top_of_page">org.freedesktop.UDisks2.NVMe.Fabrics</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("nvme-fabrics", "nvme-fabrics", "nvme-fabrics", UDISKS_TYPE_NVME_FABRICS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:block:
   *
   * The #UDisksBlock instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block.top_of_page">org.freedesktop.UDisks2.Block</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("block", "block", "block", UDISKS_TYPE_BLOCK, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:partition-table:
   *
   * The #UDisksPartitionTable instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PartitionTable.top_of_page">org.freedesktop.UDisks2.PartitionTable</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("partition-table", "partition-table", "partition-table", UDISKS_TYPE_PARTITION_TABLE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:partition:
   *
   * The #UDisksPartition instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Partition.top_of_page">org.freedesktop.UDisks2.Partition</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("partition", "partition", "partition", UDISKS_TYPE_PARTITION, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:filesystem:
   *
   * The #UDisksFilesystem instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem.top_of_page">org.freedesktop.UDisks2.Filesystem</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("filesystem", "filesystem", "filesystem", UDISKS_TYPE_FILESYSTEM, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:swapspace:
   *
   * The #UDisksSwapspace instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Swapspace.top_of_page">org.freedesktop.UDisks2.Swapspace</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("swapspace", "swapspace", "swapspace", UDISKS_TYPE_SWAPSPACE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:encrypted:
   *
   * The #UDisksEncrypted instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Encrypted.top_of_page">org.freedesktop.UDisks2.Encrypted</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("encrypted", "encrypted", "encrypted", UDISKS_TYPE_ENCRYPTED, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:loop:
   *
   * The #UDisksLoop instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Loop.top_of_page">org.freedesktop.UDisks2.Loop</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("loop", "loop", "loop", UDISKS_TYPE_LOOP, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:mdraid:
   *
   * The #UDisksMDRaid instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-MDRaid.top_of_page">org.freedesktop.UDisks2.MDRaid</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface, g_param_spec_object ("mdraid", "mdraid", "mdraid", UDISKS_TYPE_MDRAID, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:job:
   *
   * The #UDisksJob instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Job.top_of_page">org.freedesktop.UDisks2.Job</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   */
  g_object_interface_install_property (iface, g_param_spec_object ("job", "job", "job", UDISKS_TYPE_JOB, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:manager-btrfs:
   *
   * The #UDisksManagerBTRFS instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-BTRFS.top_of_page">org.freedesktop.UDisks2.Manager.BTRFS</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   *
   * Since: 2.1.3
   */
  g_object_interface_install_property (iface, g_param_spec_object ("manager-btrfs", "manager-btrfs", "manager-btrfs", UDISKS_TYPE_MANAGER_BTRFS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:filesystem-btrfs:
   *
   * The #UDisksFilesystemBTRFS instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem-BTRFS.top_of_page">org.freedesktop.UDisks2.Filesystem.BTRFS</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   *
   * Since: 2.1.3
   */
  g_object_interface_install_property (iface, g_param_spec_object ("filesystem-btrfs", "filesystem-btrfs", "filesystem-btrfs", UDISKS_TYPE_FILESYSTEM_BTRFS, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:manager-lvm2:
   *
   * The #UDisksManagerLVM2 instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-LVM2.top_of_page">org.freedesktop.UDisks2.Manager.LVM2</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface, g_param_spec_object ("manager-lvm2", "manager-lvm2", "manager-lvm2", UDISKS_TYPE_MANAGER_LVM2, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:block-lvm2:
   *
   * The #UDisksBlockLVM2 instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block-LVM2.top_of_page">org.freedesktop.UDisks2.Block.LVM2</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface, g_param_spec_object ("block-lvm2", "block-lvm2", "block-lvm2", UDISKS_TYPE_BLOCK_LVM2, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:physical-volume:
   *
   * The #UDisksPhysicalVolume instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PhysicalVolume.top_of_page">org.freedesktop.UDisks2.PhysicalVolume</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface, g_param_spec_object ("physical-volume", "physical-volume", "physical-volume", UDISKS_TYPE_PHYSICAL_VOLUME, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:volume-group:
   *
   * The #UDisksVolumeGroup instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VolumeGroup.top_of_page">org.freedesktop.UDisks2.VolumeGroup</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface, g_param_spec_object ("volume-group", "volume-group", "volume-group", UDISKS_TYPE_VOLUME_GROUP, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:logical-volume:
   *
   * The #UDisksLogicalVolume instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-LogicalVolume.top_of_page">org.freedesktop.UDisks2.LogicalVolume</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   *
   * Since: 2.0.0
   */
  g_object_interface_install_property (iface, g_param_spec_object ("logical-volume", "logical-volume", "logical-volume", UDISKS_TYPE_LOGICAL_VOLUME, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

  /**
   * UDisksObject:vdo-volume:
   *
   * The #UDisksVDOVolume instance corresponding to the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VDOVolume.top_of_page">org.freedesktop.UDisks2.VDOVolume</link>, if any.
   *
   * Connect to the #GObject::notify signal to get informed of property changes.
   *
   * Since: 2.9.0
   */
  g_object_interface_install_property (iface, g_param_spec_object ("vdo-volume", "vdo-volume", "vdo-volume", UDISKS_TYPE_VDO_VOLUME, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));

}

/**
 * udisks_object_get_manager:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksManager instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager.top_of_page">org.freedesktop.UDisks2.Manager</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksManager that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksManager *udisks_object_get_manager (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager");
  if (ret == NULL)
    return NULL;
  return UDISKS_MANAGER (ret);
}

/**
 * udisks_object_get_manager_nvme:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksManagerNVMe instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-NVMe.top_of_page">org.freedesktop.UDisks2.Manager.NVMe</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksManagerNVMe that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksManagerNVMe *udisks_object_get_manager_nvme (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager.NVMe");
  if (ret == NULL)
    return NULL;
  return UDISKS_MANAGER_NVME (ret);
}

/**
 * udisks_object_get_drive:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksDrive instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive.top_of_page">org.freedesktop.UDisks2.Drive</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksDrive that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksDrive *udisks_object_get_drive (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Drive");
  if (ret == NULL)
    return NULL;
  return UDISKS_DRIVE (ret);
}

/**
 * udisks_object_get_drive_ata:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksDriveAta instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive-Ata.top_of_page">org.freedesktop.UDisks2.Drive.Ata</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksDriveAta that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksDriveAta *udisks_object_get_drive_ata (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Drive.Ata");
  if (ret == NULL)
    return NULL;
  return UDISKS_DRIVE_ATA (ret);
}

/**
 * udisks_object_get_nvme_controller:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksNVMeController instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Controller.top_of_page">org.freedesktop.UDisks2.NVMe.Controller</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksNVMeController that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksNVMeController *udisks_object_get_nvme_controller (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.NVMe.Controller");
  if (ret == NULL)
    return NULL;
  return UDISKS_NVME_CONTROLLER (ret);
}

/**
 * udisks_object_get_nvme_namespace:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksNVMeNamespace instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Namespace.top_of_page">org.freedesktop.UDisks2.NVMe.Namespace</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksNVMeNamespace that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksNVMeNamespace *udisks_object_get_nvme_namespace (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.NVMe.Namespace");
  if (ret == NULL)
    return NULL;
  return UDISKS_NVME_NAMESPACE (ret);
}

/**
 * udisks_object_get_nvme_fabrics:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksNVMeFabrics instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Fabrics.top_of_page">org.freedesktop.UDisks2.NVMe.Fabrics</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksNVMeFabrics that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksNVMeFabrics *udisks_object_get_nvme_fabrics (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.NVMe.Fabrics");
  if (ret == NULL)
    return NULL;
  return UDISKS_NVME_FABRICS (ret);
}

/**
 * udisks_object_get_block:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksBlock instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block.top_of_page">org.freedesktop.UDisks2.Block</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksBlock that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksBlock *udisks_object_get_block (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Block");
  if (ret == NULL)
    return NULL;
  return UDISKS_BLOCK (ret);
}

/**
 * udisks_object_get_partition_table:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksPartitionTable instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PartitionTable.top_of_page">org.freedesktop.UDisks2.PartitionTable</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksPartitionTable that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksPartitionTable *udisks_object_get_partition_table (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.PartitionTable");
  if (ret == NULL)
    return NULL;
  return UDISKS_PARTITION_TABLE (ret);
}

/**
 * udisks_object_get_partition:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksPartition instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Partition.top_of_page">org.freedesktop.UDisks2.Partition</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksPartition that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksPartition *udisks_object_get_partition (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Partition");
  if (ret == NULL)
    return NULL;
  return UDISKS_PARTITION (ret);
}

/**
 * udisks_object_get_filesystem:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksFilesystem instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem.top_of_page">org.freedesktop.UDisks2.Filesystem</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksFilesystem that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksFilesystem *udisks_object_get_filesystem (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Filesystem");
  if (ret == NULL)
    return NULL;
  return UDISKS_FILESYSTEM (ret);
}

/**
 * udisks_object_get_swapspace:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksSwapspace instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Swapspace.top_of_page">org.freedesktop.UDisks2.Swapspace</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksSwapspace that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksSwapspace *udisks_object_get_swapspace (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Swapspace");
  if (ret == NULL)
    return NULL;
  return UDISKS_SWAPSPACE (ret);
}

/**
 * udisks_object_get_encrypted:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksEncrypted instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Encrypted.top_of_page">org.freedesktop.UDisks2.Encrypted</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksEncrypted that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksEncrypted *udisks_object_get_encrypted (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Encrypted");
  if (ret == NULL)
    return NULL;
  return UDISKS_ENCRYPTED (ret);
}

/**
 * udisks_object_get_loop:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksLoop instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Loop.top_of_page">org.freedesktop.UDisks2.Loop</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksLoop that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksLoop *udisks_object_get_loop (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Loop");
  if (ret == NULL)
    return NULL;
  return UDISKS_LOOP (ret);
}

/**
 * udisks_object_get_mdraid:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksMDRaid instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-MDRaid.top_of_page">org.freedesktop.UDisks2.MDRaid</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksMDRaid that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 *
 * Since: 2.0.0
 */
UDisksMDRaid *udisks_object_get_mdraid (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.MDRaid");
  if (ret == NULL)
    return NULL;
  return UDISKS_MDRAID (ret);
}

/**
 * udisks_object_get_job:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksJob instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Job.top_of_page">org.freedesktop.UDisks2.Job</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksJob that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 */
UDisksJob *udisks_object_get_job (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Job");
  if (ret == NULL)
    return NULL;
  return UDISKS_JOB (ret);
}

/**
 * udisks_object_get_manager_btrfs:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksManagerBTRFS instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-BTRFS.top_of_page">org.freedesktop.UDisks2.Manager.BTRFS</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksManagerBTRFS that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 *
 * Since: 2.1.3
 */
UDisksManagerBTRFS *udisks_object_get_manager_btrfs (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager.BTRFS");
  if (ret == NULL)
    return NULL;
  return UDISKS_MANAGER_BTRFS (ret);
}

/**
 * udisks_object_get_filesystem_btrfs:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksFilesystemBTRFS instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem-BTRFS.top_of_page">org.freedesktop.UDisks2.Filesystem.BTRFS</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksFilesystemBTRFS that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 *
 * Since: 2.1.3
 */
UDisksFilesystemBTRFS *udisks_object_get_filesystem_btrfs (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Filesystem.BTRFS");
  if (ret == NULL)
    return NULL;
  return UDISKS_FILESYSTEM_BTRFS (ret);
}

/**
 * udisks_object_get_manager_lvm2:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksManagerLVM2 instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-LVM2.top_of_page">org.freedesktop.UDisks2.Manager.LVM2</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksManagerLVM2 that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 *
 * Since: 2.0.0
 */
UDisksManagerLVM2 *udisks_object_get_manager_lvm2 (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager.LVM2");
  if (ret == NULL)
    return NULL;
  return UDISKS_MANAGER_LVM2 (ret);
}

/**
 * udisks_object_get_block_lvm2:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksBlockLVM2 instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block-LVM2.top_of_page">org.freedesktop.UDisks2.Block.LVM2</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksBlockLVM2 that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 *
 * Since: 2.0.0
 */
UDisksBlockLVM2 *udisks_object_get_block_lvm2 (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Block.LVM2");
  if (ret == NULL)
    return NULL;
  return UDISKS_BLOCK_LVM2 (ret);
}

/**
 * udisks_object_get_physical_volume:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksPhysicalVolume instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PhysicalVolume.top_of_page">org.freedesktop.UDisks2.PhysicalVolume</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksPhysicalVolume that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 *
 * Since: 2.0.0
 */
UDisksPhysicalVolume *udisks_object_get_physical_volume (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.PhysicalVolume");
  if (ret == NULL)
    return NULL;
  return UDISKS_PHYSICAL_VOLUME (ret);
}

/**
 * udisks_object_get_volume_group:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksVolumeGroup instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VolumeGroup.top_of_page">org.freedesktop.UDisks2.VolumeGroup</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksVolumeGroup that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 *
 * Since: 2.0.0
 */
UDisksVolumeGroup *udisks_object_get_volume_group (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.VolumeGroup");
  if (ret == NULL)
    return NULL;
  return UDISKS_VOLUME_GROUP (ret);
}

/**
 * udisks_object_get_logical_volume:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksLogicalVolume instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-LogicalVolume.top_of_page">org.freedesktop.UDisks2.LogicalVolume</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksLogicalVolume that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 *
 * Since: 2.0.0
 */
UDisksLogicalVolume *udisks_object_get_logical_volume (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.LogicalVolume");
  if (ret == NULL)
    return NULL;
  return UDISKS_LOGICAL_VOLUME (ret);
}

/**
 * udisks_object_get_vdo_volume:
 * @object: A #UDisksObject.
 *
 * Gets the #UDisksVDOVolume instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VDOVolume.top_of_page">org.freedesktop.UDisks2.VDOVolume</link> on @object, if any.
 *
 * Returns: (transfer full) (nullable): A #UDisksVDOVolume that must be freed with g_object_unref() or %NULL if @object does not implement the interface.
 *
 * Since: 2.9.0
 */
UDisksVDOVolume *udisks_object_get_vdo_volume (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.VDOVolume");
  if (ret == NULL)
    return NULL;
  return UDISKS_VDO_VOLUME (ret);
}


/**
 * udisks_object_peek_manager: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_manager() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksManager or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksManager *udisks_object_peek_manager (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_MANAGER (ret);
}

/**
 * udisks_object_peek_manager_nvme: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_manager_nvme() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksManagerNVMe or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksManagerNVMe *udisks_object_peek_manager_nvme (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager.NVMe");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_MANAGER_NVME (ret);
}

/**
 * udisks_object_peek_drive: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_drive() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksDrive or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksDrive *udisks_object_peek_drive (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Drive");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_DRIVE (ret);
}

/**
 * udisks_object_peek_drive_ata: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_drive_ata() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksDriveAta or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksDriveAta *udisks_object_peek_drive_ata (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Drive.Ata");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_DRIVE_ATA (ret);
}

/**
 * udisks_object_peek_nvme_controller: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_nvme_controller() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksNVMeController or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksNVMeController *udisks_object_peek_nvme_controller (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.NVMe.Controller");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_NVME_CONTROLLER (ret);
}

/**
 * udisks_object_peek_nvme_namespace: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_nvme_namespace() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksNVMeNamespace or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksNVMeNamespace *udisks_object_peek_nvme_namespace (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.NVMe.Namespace");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_NVME_NAMESPACE (ret);
}

/**
 * udisks_object_peek_nvme_fabrics: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_nvme_fabrics() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksNVMeFabrics or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksNVMeFabrics *udisks_object_peek_nvme_fabrics (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.NVMe.Fabrics");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_NVME_FABRICS (ret);
}

/**
 * udisks_object_peek_block: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_block() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksBlock or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksBlock *udisks_object_peek_block (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Block");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_BLOCK (ret);
}

/**
 * udisks_object_peek_partition_table: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_partition_table() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksPartitionTable or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksPartitionTable *udisks_object_peek_partition_table (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.PartitionTable");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_PARTITION_TABLE (ret);
}

/**
 * udisks_object_peek_partition: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_partition() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksPartition or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksPartition *udisks_object_peek_partition (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Partition");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_PARTITION (ret);
}

/**
 * udisks_object_peek_filesystem: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_filesystem() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksFilesystem or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksFilesystem *udisks_object_peek_filesystem (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Filesystem");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_FILESYSTEM (ret);
}

/**
 * udisks_object_peek_swapspace: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_swapspace() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksSwapspace or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksSwapspace *udisks_object_peek_swapspace (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Swapspace");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_SWAPSPACE (ret);
}

/**
 * udisks_object_peek_encrypted: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_encrypted() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksEncrypted or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksEncrypted *udisks_object_peek_encrypted (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Encrypted");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_ENCRYPTED (ret);
}

/**
 * udisks_object_peek_loop: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_loop() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksLoop or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksLoop *udisks_object_peek_loop (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Loop");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_LOOP (ret);
}

/**
 * udisks_object_peek_mdraid: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_mdraid() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksMDRaid or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 *
 * Since: 2.0.0
 */
UDisksMDRaid *udisks_object_peek_mdraid (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.MDRaid");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_MDRAID (ret);
}

/**
 * udisks_object_peek_job: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_job() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksJob or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 */
UDisksJob *udisks_object_peek_job (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Job");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_JOB (ret);
}

/**
 * udisks_object_peek_manager_btrfs: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_manager_btrfs() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksManagerBTRFS or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 *
 * Since: 2.1.3
 */
UDisksManagerBTRFS *udisks_object_peek_manager_btrfs (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager.BTRFS");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_MANAGER_BTRFS (ret);
}

/**
 * udisks_object_peek_filesystem_btrfs: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_filesystem_btrfs() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksFilesystemBTRFS or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 *
 * Since: 2.1.3
 */
UDisksFilesystemBTRFS *udisks_object_peek_filesystem_btrfs (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Filesystem.BTRFS");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_FILESYSTEM_BTRFS (ret);
}

/**
 * udisks_object_peek_manager_lvm2: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_manager_lvm2() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksManagerLVM2 or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 *
 * Since: 2.0.0
 */
UDisksManagerLVM2 *udisks_object_peek_manager_lvm2 (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager.LVM2");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_MANAGER_LVM2 (ret);
}

/**
 * udisks_object_peek_block_lvm2: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_block_lvm2() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksBlockLVM2 or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 *
 * Since: 2.0.0
 */
UDisksBlockLVM2 *udisks_object_peek_block_lvm2 (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Block.LVM2");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_BLOCK_LVM2 (ret);
}

/**
 * udisks_object_peek_physical_volume: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_physical_volume() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksPhysicalVolume or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 *
 * Since: 2.0.0
 */
UDisksPhysicalVolume *udisks_object_peek_physical_volume (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.PhysicalVolume");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_PHYSICAL_VOLUME (ret);
}

/**
 * udisks_object_peek_volume_group: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_volume_group() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksVolumeGroup or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 *
 * Since: 2.0.0
 */
UDisksVolumeGroup *udisks_object_peek_volume_group (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.VolumeGroup");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_VOLUME_GROUP (ret);
}

/**
 * udisks_object_peek_logical_volume: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_logical_volume() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksLogicalVolume or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 *
 * Since: 2.0.0
 */
UDisksLogicalVolume *udisks_object_peek_logical_volume (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.LogicalVolume");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_LOGICAL_VOLUME (ret);
}

/**
 * udisks_object_peek_vdo_volume: (skip)
 * @object: A #UDisksObject.
 *
 * Like udisks_object_get_vdo_volume() but doesn't increase the reference count on the returned object.
 *
 * It is not safe to use the returned object if you are on another thread than the one where the #GDBusObjectManagerClient or #GDBusObjectManagerServer for @object is running.
 *
 * Returns: (transfer none) (nullable): A #UDisksVDOVolume or %NULL if @object does not implement the interface. Do not free the returned object, it is owned by @object.
 *
 * Since: 2.9.0
 */
UDisksVDOVolume *udisks_object_peek_vdo_volume (UDisksObject *object)
{
  GDBusInterface *ret;
  ret = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.VDOVolume");
  if (ret == NULL)
    return NULL;
  g_object_unref (ret);
  return UDISKS_VDO_VOLUME (ret);
}


static void
udisks_object_notify (GDBusObject *object, GDBusInterface *interface)
{
  _ExtendedGDBusInterfaceInfo *info = (_ExtendedGDBusInterfaceInfo *) g_dbus_interface_get_info (interface);
  /* info can be NULL if the other end is using a D-Bus interface we don't know
   * anything about, for example old generated code in this process talking to
   * newer generated code in the other process. */
  if (info != NULL)
    g_object_notify (G_OBJECT (object), info->hyphen_name);
}

/**
 * UDisksObjectProxy:
 *
 * The #UDisksObjectProxy structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksObjectProxyClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksObjectProxy.
 */

static void
udisks_object_proxy__udisks_object_iface_init (UDisksObjectIface *iface G_GNUC_UNUSED)
{
}

static void
udisks_object_proxy__g_dbus_object_iface_init (GDBusObjectIface *iface)
{
  iface->interface_added = udisks_object_notify;
  iface->interface_removed = udisks_object_notify;
}


G_DEFINE_TYPE_WITH_CODE (UDisksObjectProxy, udisks_object_proxy, G_TYPE_DBUS_OBJECT_PROXY,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_OBJECT, udisks_object_proxy__udisks_object_iface_init)
                         G_IMPLEMENT_INTERFACE (G_TYPE_DBUS_OBJECT, udisks_object_proxy__g_dbus_object_iface_init))

static void
udisks_object_proxy_init (UDisksObjectProxy *object G_GNUC_UNUSED)
{
}

static void
udisks_object_proxy_set_property (GObject      *gobject,
  guint         prop_id,
  const GValue *value G_GNUC_UNUSED,
  GParamSpec   *pspec)
{
  G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
}

static void
udisks_object_proxy_get_property (GObject      *gobject,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec)
{
  UDisksObjectProxy *object = UDISKS_OBJECT_PROXY (gobject);
  GDBusInterface *interface;

  switch (prop_id)
    {
    case 1:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager");
      g_value_take_object (value, interface);
      break;

    case 2:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager.NVMe");
      g_value_take_object (value, interface);
      break;

    case 3:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Drive");
      g_value_take_object (value, interface);
      break;

    case 4:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Drive.Ata");
      g_value_take_object (value, interface);
      break;

    case 5:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.NVMe.Controller");
      g_value_take_object (value, interface);
      break;

    case 6:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.NVMe.Namespace");
      g_value_take_object (value, interface);
      break;

    case 7:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.NVMe.Fabrics");
      g_value_take_object (value, interface);
      break;

    case 8:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Block");
      g_value_take_object (value, interface);
      break;

    case 9:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.PartitionTable");
      g_value_take_object (value, interface);
      break;

    case 10:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Partition");
      g_value_take_object (value, interface);
      break;

    case 11:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Filesystem");
      g_value_take_object (value, interface);
      break;

    case 12:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Swapspace");
      g_value_take_object (value, interface);
      break;

    case 13:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Encrypted");
      g_value_take_object (value, interface);
      break;

    case 14:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Loop");
      g_value_take_object (value, interface);
      break;

    case 15:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.MDRaid");
      g_value_take_object (value, interface);
      break;

    case 16:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Job");
      g_value_take_object (value, interface);
      break;

    case 17:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager.BTRFS");
      g_value_take_object (value, interface);
      break;

    case 18:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Filesystem.BTRFS");
      g_value_take_object (value, interface);
      break;

    case 19:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager.LVM2");
      g_value_take_object (value, interface);
      break;

    case 20:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Block.LVM2");
      g_value_take_object (value, interface);
      break;

    case 21:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.PhysicalVolume");
      g_value_take_object (value, interface);
      break;

    case 22:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.VolumeGroup");
      g_value_take_object (value, interface);
      break;

    case 23:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.LogicalVolume");
      g_value_take_object (value, interface);
      break;

    case 24:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.VDOVolume");
      g_value_take_object (value, interface);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
      break;
  }
}

static void
udisks_object_proxy_class_init (UDisksObjectProxyClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->set_property = udisks_object_proxy_set_property;
  gobject_class->get_property = udisks_object_proxy_get_property;

  g_object_class_override_property (gobject_class, 1, "manager");
  g_object_class_override_property (gobject_class, 2, "manager-nvme");
  g_object_class_override_property (gobject_class, 3, "drive");
  g_object_class_override_property (gobject_class, 4, "drive-ata");
  g_object_class_override_property (gobject_class, 5, "nvme-controller");
  g_object_class_override_property (gobject_class, 6, "nvme-namespace");
  g_object_class_override_property (gobject_class, 7, "nvme-fabrics");
  g_object_class_override_property (gobject_class, 8, "block");
  g_object_class_override_property (gobject_class, 9, "partition-table");
  g_object_class_override_property (gobject_class, 10, "partition");
  g_object_class_override_property (gobject_class, 11, "filesystem");
  g_object_class_override_property (gobject_class, 12, "swapspace");
  g_object_class_override_property (gobject_class, 13, "encrypted");
  g_object_class_override_property (gobject_class, 14, "loop");
  g_object_class_override_property (gobject_class, 15, "mdraid");
  g_object_class_override_property (gobject_class, 16, "job");
  g_object_class_override_property (gobject_class, 17, "manager-btrfs");
  g_object_class_override_property (gobject_class, 18, "filesystem-btrfs");
  g_object_class_override_property (gobject_class, 19, "manager-lvm2");
  g_object_class_override_property (gobject_class, 20, "block-lvm2");
  g_object_class_override_property (gobject_class, 21, "physical-volume");
  g_object_class_override_property (gobject_class, 22, "volume-group");
  g_object_class_override_property (gobject_class, 23, "logical-volume");
  g_object_class_override_property (gobject_class, 24, "vdo-volume");
}

/**
 * udisks_object_proxy_new:
 * @connection: A #GDBusConnection.
 * @object_path: An object path.
 *
 * Creates a new proxy object.
 *
 * Returns: (transfer full): The proxy object.
 */
UDisksObjectProxy *
udisks_object_proxy_new (GDBusConnection *connection,
  const gchar *object_path)
{
  g_return_val_if_fail (G_IS_DBUS_CONNECTION (connection), NULL);
  g_return_val_if_fail (g_variant_is_object_path (object_path), NULL);
  return UDISKS_OBJECT_PROXY (g_object_new (UDISKS_TYPE_OBJECT_PROXY, "g-connection", connection, "g-object-path", object_path, NULL));
}

/**
 * UDisksObjectSkeleton:
 *
 * The #UDisksObjectSkeleton structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksObjectSkeletonClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksObjectSkeleton.
 */

static void
udisks_object_skeleton__udisks_object_iface_init (UDisksObjectIface *iface G_GNUC_UNUSED)
{
}


static void
udisks_object_skeleton__g_dbus_object_iface_init (GDBusObjectIface *iface)
{
  iface->interface_added = udisks_object_notify;
  iface->interface_removed = udisks_object_notify;
}

G_DEFINE_TYPE_WITH_CODE (UDisksObjectSkeleton, udisks_object_skeleton, G_TYPE_DBUS_OBJECT_SKELETON,
                         G_IMPLEMENT_INTERFACE (UDISKS_TYPE_OBJECT, udisks_object_skeleton__udisks_object_iface_init)
                         G_IMPLEMENT_INTERFACE (G_TYPE_DBUS_OBJECT, udisks_object_skeleton__g_dbus_object_iface_init))

static void
udisks_object_skeleton_init (UDisksObjectSkeleton *object G_GNUC_UNUSED)
{
}

static void
udisks_object_skeleton_set_property (GObject      *gobject,
  guint         prop_id,
  const GValue *value,
  GParamSpec   *pspec)
{
  UDisksObjectSkeleton *object = UDISKS_OBJECT_SKELETON (gobject);
  GDBusInterfaceSkeleton *interface;

  switch (prop_id)
    {
    case 1:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_MANAGER (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Manager");
        }
      break;

    case 2:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_MANAGER_NVME (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Manager.NVMe");
        }
      break;

    case 3:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_DRIVE (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Drive");
        }
      break;

    case 4:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_DRIVE_ATA (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Drive.Ata");
        }
      break;

    case 5:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_NVME_CONTROLLER (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.NVMe.Controller");
        }
      break;

    case 6:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_NVME_NAMESPACE (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.NVMe.Namespace");
        }
      break;

    case 7:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_NVME_FABRICS (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.NVMe.Fabrics");
        }
      break;

    case 8:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_BLOCK (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Block");
        }
      break;

    case 9:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_PARTITION_TABLE (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.PartitionTable");
        }
      break;

    case 10:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_PARTITION (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Partition");
        }
      break;

    case 11:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_FILESYSTEM (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Filesystem");
        }
      break;

    case 12:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_SWAPSPACE (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Swapspace");
        }
      break;

    case 13:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_ENCRYPTED (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Encrypted");
        }
      break;

    case 14:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_LOOP (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Loop");
        }
      break;

    case 15:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_MDRAID (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.MDRaid");
        }
      break;

    case 16:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_JOB (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Job");
        }
      break;

    case 17:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_MANAGER_BTRFS (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Manager.BTRFS");
        }
      break;

    case 18:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_FILESYSTEM_BTRFS (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Filesystem.BTRFS");
        }
      break;

    case 19:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_MANAGER_LVM2 (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Manager.LVM2");
        }
      break;

    case 20:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_BLOCK_LVM2 (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.Block.LVM2");
        }
      break;

    case 21:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_PHYSICAL_VOLUME (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.PhysicalVolume");
        }
      break;

    case 22:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_VOLUME_GROUP (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.VolumeGroup");
        }
      break;

    case 23:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_LOGICAL_VOLUME (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.LogicalVolume");
        }
      break;

    case 24:
      interface = g_value_get_object (value);
      if (interface != NULL)
        {
          g_warn_if_fail (UDISKS_IS_VDO_VOLUME (interface));
          g_dbus_object_skeleton_add_interface (G_DBUS_OBJECT_SKELETON (object), interface);
        }
      else
        {
          g_dbus_object_skeleton_remove_interface_by_name (G_DBUS_OBJECT_SKELETON (object), "org.freedesktop.UDisks2.VDOVolume");
        }
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
      break;
  }
}

static void
udisks_object_skeleton_get_property (GObject      *gobject,
  guint         prop_id,
  GValue       *value,
  GParamSpec   *pspec)
{
  UDisksObjectSkeleton *object = UDISKS_OBJECT_SKELETON (gobject);
  GDBusInterface *interface;

  switch (prop_id)
    {
    case 1:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager");
      g_value_take_object (value, interface);
      break;

    case 2:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager.NVMe");
      g_value_take_object (value, interface);
      break;

    case 3:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Drive");
      g_value_take_object (value, interface);
      break;

    case 4:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Drive.Ata");
      g_value_take_object (value, interface);
      break;

    case 5:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.NVMe.Controller");
      g_value_take_object (value, interface);
      break;

    case 6:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.NVMe.Namespace");
      g_value_take_object (value, interface);
      break;

    case 7:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.NVMe.Fabrics");
      g_value_take_object (value, interface);
      break;

    case 8:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Block");
      g_value_take_object (value, interface);
      break;

    case 9:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.PartitionTable");
      g_value_take_object (value, interface);
      break;

    case 10:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Partition");
      g_value_take_object (value, interface);
      break;

    case 11:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Filesystem");
      g_value_take_object (value, interface);
      break;

    case 12:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Swapspace");
      g_value_take_object (value, interface);
      break;

    case 13:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Encrypted");
      g_value_take_object (value, interface);
      break;

    case 14:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Loop");
      g_value_take_object (value, interface);
      break;

    case 15:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.MDRaid");
      g_value_take_object (value, interface);
      break;

    case 16:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Job");
      g_value_take_object (value, interface);
      break;

    case 17:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager.BTRFS");
      g_value_take_object (value, interface);
      break;

    case 18:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Filesystem.BTRFS");
      g_value_take_object (value, interface);
      break;

    case 19:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Manager.LVM2");
      g_value_take_object (value, interface);
      break;

    case 20:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.Block.LVM2");
      g_value_take_object (value, interface);
      break;

    case 21:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.PhysicalVolume");
      g_value_take_object (value, interface);
      break;

    case 22:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.VolumeGroup");
      g_value_take_object (value, interface);
      break;

    case 23:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.LogicalVolume");
      g_value_take_object (value, interface);
      break;

    case 24:
      interface = g_dbus_object_get_interface (G_DBUS_OBJECT (object), "org.freedesktop.UDisks2.VDOVolume");
      g_value_take_object (value, interface);
      break;

    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (gobject, prop_id, pspec);
      break;
  }
}

static void
udisks_object_skeleton_class_init (UDisksObjectSkeletonClass *klass)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (klass);

  gobject_class->set_property = udisks_object_skeleton_set_property;
  gobject_class->get_property = udisks_object_skeleton_get_property;

  g_object_class_override_property (gobject_class, 1, "manager");
  g_object_class_override_property (gobject_class, 2, "manager-nvme");
  g_object_class_override_property (gobject_class, 3, "drive");
  g_object_class_override_property (gobject_class, 4, "drive-ata");
  g_object_class_override_property (gobject_class, 5, "nvme-controller");
  g_object_class_override_property (gobject_class, 6, "nvme-namespace");
  g_object_class_override_property (gobject_class, 7, "nvme-fabrics");
  g_object_class_override_property (gobject_class, 8, "block");
  g_object_class_override_property (gobject_class, 9, "partition-table");
  g_object_class_override_property (gobject_class, 10, "partition");
  g_object_class_override_property (gobject_class, 11, "filesystem");
  g_object_class_override_property (gobject_class, 12, "swapspace");
  g_object_class_override_property (gobject_class, 13, "encrypted");
  g_object_class_override_property (gobject_class, 14, "loop");
  g_object_class_override_property (gobject_class, 15, "mdraid");
  g_object_class_override_property (gobject_class, 16, "job");
  g_object_class_override_property (gobject_class, 17, "manager-btrfs");
  g_object_class_override_property (gobject_class, 18, "filesystem-btrfs");
  g_object_class_override_property (gobject_class, 19, "manager-lvm2");
  g_object_class_override_property (gobject_class, 20, "block-lvm2");
  g_object_class_override_property (gobject_class, 21, "physical-volume");
  g_object_class_override_property (gobject_class, 22, "volume-group");
  g_object_class_override_property (gobject_class, 23, "logical-volume");
  g_object_class_override_property (gobject_class, 24, "vdo-volume");
}

/**
 * udisks_object_skeleton_new:
 * @object_path: An object path.
 *
 * Creates a new skeleton object.
 *
 * Returns: (transfer full): The skeleton object.
 */
UDisksObjectSkeleton *
udisks_object_skeleton_new (const gchar *object_path)
{
  g_return_val_if_fail (g_variant_is_object_path (object_path), NULL);
  return UDISKS_OBJECT_SKELETON (g_object_new (UDISKS_TYPE_OBJECT_SKELETON, "g-object-path", object_path, NULL));
}

/**
 * udisks_object_skeleton_set_manager:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksManager or %NULL to clear the interface.
 *
 * Sets the #UDisksManager instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager.top_of_page">org.freedesktop.UDisks2.Manager</link> on @object.
 */
void udisks_object_skeleton_set_manager (UDisksObjectSkeleton *object, UDisksManager *interface_)
{
  g_object_set (G_OBJECT (object), "manager", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_manager_nvme:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksManagerNVMe or %NULL to clear the interface.
 *
 * Sets the #UDisksManagerNVMe instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-NVMe.top_of_page">org.freedesktop.UDisks2.Manager.NVMe</link> on @object.
 */
void udisks_object_skeleton_set_manager_nvme (UDisksObjectSkeleton *object, UDisksManagerNVMe *interface_)
{
  g_object_set (G_OBJECT (object), "manager-nvme", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_drive:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksDrive or %NULL to clear the interface.
 *
 * Sets the #UDisksDrive instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive.top_of_page">org.freedesktop.UDisks2.Drive</link> on @object.
 */
void udisks_object_skeleton_set_drive (UDisksObjectSkeleton *object, UDisksDrive *interface_)
{
  g_object_set (G_OBJECT (object), "drive", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_drive_ata:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksDriveAta or %NULL to clear the interface.
 *
 * Sets the #UDisksDriveAta instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Drive-Ata.top_of_page">org.freedesktop.UDisks2.Drive.Ata</link> on @object.
 */
void udisks_object_skeleton_set_drive_ata (UDisksObjectSkeleton *object, UDisksDriveAta *interface_)
{
  g_object_set (G_OBJECT (object), "drive-ata", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_nvme_controller:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksNVMeController or %NULL to clear the interface.
 *
 * Sets the #UDisksNVMeController instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Controller.top_of_page">org.freedesktop.UDisks2.NVMe.Controller</link> on @object.
 */
void udisks_object_skeleton_set_nvme_controller (UDisksObjectSkeleton *object, UDisksNVMeController *interface_)
{
  g_object_set (G_OBJECT (object), "nvme-controller", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_nvme_namespace:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksNVMeNamespace or %NULL to clear the interface.
 *
 * Sets the #UDisksNVMeNamespace instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Namespace.top_of_page">org.freedesktop.UDisks2.NVMe.Namespace</link> on @object.
 */
void udisks_object_skeleton_set_nvme_namespace (UDisksObjectSkeleton *object, UDisksNVMeNamespace *interface_)
{
  g_object_set (G_OBJECT (object), "nvme-namespace", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_nvme_fabrics:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksNVMeFabrics or %NULL to clear the interface.
 *
 * Sets the #UDisksNVMeFabrics instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-NVMe-Fabrics.top_of_page">org.freedesktop.UDisks2.NVMe.Fabrics</link> on @object.
 */
void udisks_object_skeleton_set_nvme_fabrics (UDisksObjectSkeleton *object, UDisksNVMeFabrics *interface_)
{
  g_object_set (G_OBJECT (object), "nvme-fabrics", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_block:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksBlock or %NULL to clear the interface.
 *
 * Sets the #UDisksBlock instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block.top_of_page">org.freedesktop.UDisks2.Block</link> on @object.
 */
void udisks_object_skeleton_set_block (UDisksObjectSkeleton *object, UDisksBlock *interface_)
{
  g_object_set (G_OBJECT (object), "block", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_partition_table:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksPartitionTable or %NULL to clear the interface.
 *
 * Sets the #UDisksPartitionTable instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PartitionTable.top_of_page">org.freedesktop.UDisks2.PartitionTable</link> on @object.
 */
void udisks_object_skeleton_set_partition_table (UDisksObjectSkeleton *object, UDisksPartitionTable *interface_)
{
  g_object_set (G_OBJECT (object), "partition-table", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_partition:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksPartition or %NULL to clear the interface.
 *
 * Sets the #UDisksPartition instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Partition.top_of_page">org.freedesktop.UDisks2.Partition</link> on @object.
 */
void udisks_object_skeleton_set_partition (UDisksObjectSkeleton *object, UDisksPartition *interface_)
{
  g_object_set (G_OBJECT (object), "partition", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_filesystem:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksFilesystem or %NULL to clear the interface.
 *
 * Sets the #UDisksFilesystem instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem.top_of_page">org.freedesktop.UDisks2.Filesystem</link> on @object.
 */
void udisks_object_skeleton_set_filesystem (UDisksObjectSkeleton *object, UDisksFilesystem *interface_)
{
  g_object_set (G_OBJECT (object), "filesystem", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_swapspace:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksSwapspace or %NULL to clear the interface.
 *
 * Sets the #UDisksSwapspace instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Swapspace.top_of_page">org.freedesktop.UDisks2.Swapspace</link> on @object.
 */
void udisks_object_skeleton_set_swapspace (UDisksObjectSkeleton *object, UDisksSwapspace *interface_)
{
  g_object_set (G_OBJECT (object), "swapspace", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_encrypted:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksEncrypted or %NULL to clear the interface.
 *
 * Sets the #UDisksEncrypted instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Encrypted.top_of_page">org.freedesktop.UDisks2.Encrypted</link> on @object.
 */
void udisks_object_skeleton_set_encrypted (UDisksObjectSkeleton *object, UDisksEncrypted *interface_)
{
  g_object_set (G_OBJECT (object), "encrypted", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_loop:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksLoop or %NULL to clear the interface.
 *
 * Sets the #UDisksLoop instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Loop.top_of_page">org.freedesktop.UDisks2.Loop</link> on @object.
 */
void udisks_object_skeleton_set_loop (UDisksObjectSkeleton *object, UDisksLoop *interface_)
{
  g_object_set (G_OBJECT (object), "loop", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_mdraid:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksMDRaid or %NULL to clear the interface.
 *
 * Sets the #UDisksMDRaid instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-MDRaid.top_of_page">org.freedesktop.UDisks2.MDRaid</link> on @object.
 *
 * Since: 2.0.0
 */
void udisks_object_skeleton_set_mdraid (UDisksObjectSkeleton *object, UDisksMDRaid *interface_)
{
  g_object_set (G_OBJECT (object), "mdraid", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_job:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksJob or %NULL to clear the interface.
 *
 * Sets the #UDisksJob instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Job.top_of_page">org.freedesktop.UDisks2.Job</link> on @object.
 */
void udisks_object_skeleton_set_job (UDisksObjectSkeleton *object, UDisksJob *interface_)
{
  g_object_set (G_OBJECT (object), "job", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_manager_btrfs:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksManagerBTRFS or %NULL to clear the interface.
 *
 * Sets the #UDisksManagerBTRFS instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-BTRFS.top_of_page">org.freedesktop.UDisks2.Manager.BTRFS</link> on @object.
 *
 * Since: 2.1.3
 */
void udisks_object_skeleton_set_manager_btrfs (UDisksObjectSkeleton *object, UDisksManagerBTRFS *interface_)
{
  g_object_set (G_OBJECT (object), "manager-btrfs", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_filesystem_btrfs:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksFilesystemBTRFS or %NULL to clear the interface.
 *
 * Sets the #UDisksFilesystemBTRFS instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Filesystem-BTRFS.top_of_page">org.freedesktop.UDisks2.Filesystem.BTRFS</link> on @object.
 *
 * Since: 2.1.3
 */
void udisks_object_skeleton_set_filesystem_btrfs (UDisksObjectSkeleton *object, UDisksFilesystemBTRFS *interface_)
{
  g_object_set (G_OBJECT (object), "filesystem-btrfs", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_manager_lvm2:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksManagerLVM2 or %NULL to clear the interface.
 *
 * Sets the #UDisksManagerLVM2 instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Manager-LVM2.top_of_page">org.freedesktop.UDisks2.Manager.LVM2</link> on @object.
 *
 * Since: 2.0.0
 */
void udisks_object_skeleton_set_manager_lvm2 (UDisksObjectSkeleton *object, UDisksManagerLVM2 *interface_)
{
  g_object_set (G_OBJECT (object), "manager-lvm2", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_block_lvm2:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksBlockLVM2 or %NULL to clear the interface.
 *
 * Sets the #UDisksBlockLVM2 instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-Block-LVM2.top_of_page">org.freedesktop.UDisks2.Block.LVM2</link> on @object.
 *
 * Since: 2.0.0
 */
void udisks_object_skeleton_set_block_lvm2 (UDisksObjectSkeleton *object, UDisksBlockLVM2 *interface_)
{
  g_object_set (G_OBJECT (object), "block-lvm2", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_physical_volume:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksPhysicalVolume or %NULL to clear the interface.
 *
 * Sets the #UDisksPhysicalVolume instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-PhysicalVolume.top_of_page">org.freedesktop.UDisks2.PhysicalVolume</link> on @object.
 *
 * Since: 2.0.0
 */
void udisks_object_skeleton_set_physical_volume (UDisksObjectSkeleton *object, UDisksPhysicalVolume *interface_)
{
  g_object_set (G_OBJECT (object), "physical-volume", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_volume_group:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksVolumeGroup or %NULL to clear the interface.
 *
 * Sets the #UDisksVolumeGroup instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VolumeGroup.top_of_page">org.freedesktop.UDisks2.VolumeGroup</link> on @object.
 *
 * Since: 2.0.0
 */
void udisks_object_skeleton_set_volume_group (UDisksObjectSkeleton *object, UDisksVolumeGroup *interface_)
{
  g_object_set (G_OBJECT (object), "volume-group", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_logical_volume:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksLogicalVolume or %NULL to clear the interface.
 *
 * Sets the #UDisksLogicalVolume instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-LogicalVolume.top_of_page">org.freedesktop.UDisks2.LogicalVolume</link> on @object.
 *
 * Since: 2.0.0
 */
void udisks_object_skeleton_set_logical_volume (UDisksObjectSkeleton *object, UDisksLogicalVolume *interface_)
{
  g_object_set (G_OBJECT (object), "logical-volume", interface_, NULL);
}

/**
 * udisks_object_skeleton_set_vdo_volume:
 * @object: A #UDisksObjectSkeleton.
 * @interface_: (nullable): A #UDisksVDOVolume or %NULL to clear the interface.
 *
 * Sets the #UDisksVDOVolume instance for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks2-VDOVolume.top_of_page">org.freedesktop.UDisks2.VDOVolume</link> on @object.
 *
 * Since: 2.9.0
 */
void udisks_object_skeleton_set_vdo_volume (UDisksObjectSkeleton *object, UDisksVDOVolume *interface_)
{
  g_object_set (G_OBJECT (object), "vdo-volume", interface_, NULL);
}


/* ------------------------------------------------------------------------
 * Code for ObjectManager client
 * ------------------------------------------------------------------------
 */

/**
 * SECTION:UDisksObjectManagerClient
 * @title: UDisksObjectManagerClient
 * @short_description: Generated GDBusObjectManagerClient type
 *
 * This section contains a #GDBusObjectManagerClient that uses udisks_object_manager_client_get_proxy_type() as the #GDBusProxyTypeFunc.
 */

/**
 * UDisksObjectManagerClient:
 *
 * The #UDisksObjectManagerClient structure contains only private data and should only be accessed using the provided API.
 */

/**
 * UDisksObjectManagerClientClass:
 * @parent_class: The parent class.
 *
 * Class structure for #UDisksObjectManagerClient.
 */

G_DEFINE_TYPE (UDisksObjectManagerClient, udisks_object_manager_client, G_TYPE_DBUS_OBJECT_MANAGER_CLIENT)

static void
udisks_object_manager_client_init (UDisksObjectManagerClient *manager G_GNUC_UNUSED)
{
}

static void
udisks_object_manager_client_class_init (UDisksObjectManagerClientClass *klass G_GNUC_UNUSED)
{
}

/**
 * udisks_object_manager_client_get_proxy_type:
 * @manager: A #GDBusObjectManagerClient.
 * @object_path: The object path of the remote object (unused).
 * @interface_name: (nullable): Interface name of the remote object or %NULL to get the object proxy #GType.
 * @user_data: User data (unused).
 *
 * A #GDBusProxyTypeFunc that maps @interface_name to the generated #GDBusObjectProxy derived and #GDBusProxy derived types.
 *
 * Returns: A #GDBusProxy derived #GType if @interface_name is not %NULL, otherwise the #GType for #UDisksObjectProxy.
 */
GType
udisks_object_manager_client_get_proxy_type (GDBusObjectManagerClient *manager G_GNUC_UNUSED, const gchar *object_path G_GNUC_UNUSED, const gchar *interface_name, gpointer user_data G_GNUC_UNUSED)
{
  static gsize once_init_value = 0;
  static GHashTable *lookup_hash;
  GType ret;

  if (interface_name == NULL)
    return UDISKS_TYPE_OBJECT_PROXY;
  if (g_once_init_enter (&once_init_value))
    {
      lookup_hash = g_hash_table_new (g_str_hash, g_str_equal);
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Manager", (gpointer) (guintptr) (UDISKS_TYPE_MANAGER_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Manager.NVMe", (gpointer) (guintptr) (UDISKS_TYPE_MANAGER_NVME_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Drive", (gpointer) (guintptr) (UDISKS_TYPE_DRIVE_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Drive.Ata", (gpointer) (guintptr) (UDISKS_TYPE_DRIVE_ATA_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.NVMe.Controller", (gpointer) (guintptr) (UDISKS_TYPE_NVME_CONTROLLER_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.NVMe.Namespace", (gpointer) (guintptr) (UDISKS_TYPE_NVME_NAMESPACE_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.NVMe.Fabrics", (gpointer) (guintptr) (UDISKS_TYPE_NVME_FABRICS_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Block", (gpointer) (guintptr) (UDISKS_TYPE_BLOCK_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.PartitionTable", (gpointer) (guintptr) (UDISKS_TYPE_PARTITION_TABLE_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Partition", (gpointer) (guintptr) (UDISKS_TYPE_PARTITION_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Filesystem", (gpointer) (guintptr) (UDISKS_TYPE_FILESYSTEM_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Swapspace", (gpointer) (guintptr) (UDISKS_TYPE_SWAPSPACE_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Encrypted", (gpointer) (guintptr) (UDISKS_TYPE_ENCRYPTED_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Loop", (gpointer) (guintptr) (UDISKS_TYPE_LOOP_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.MDRaid", (gpointer) (guintptr) (UDISKS_TYPE_MDRAID_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Job", (gpointer) (guintptr) (UDISKS_TYPE_JOB_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Manager.BTRFS", (gpointer) (guintptr) (UDISKS_TYPE_MANAGER_BTRFS_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Filesystem.BTRFS", (gpointer) (guintptr) (UDISKS_TYPE_FILESYSTEM_BTRFS_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Manager.LVM2", (gpointer) (guintptr) (UDISKS_TYPE_MANAGER_LVM2_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.Block.LVM2", (gpointer) (guintptr) (UDISKS_TYPE_BLOCK_LVM2_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.PhysicalVolume", (gpointer) (guintptr) (UDISKS_TYPE_PHYSICAL_VOLUME_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.VolumeGroup", (gpointer) (guintptr) (UDISKS_TYPE_VOLUME_GROUP_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.LogicalVolume", (gpointer) (guintptr) (UDISKS_TYPE_LOGICAL_VOLUME_PROXY));
      g_hash_table_insert (lookup_hash, (gpointer) "org.freedesktop.UDisks2.VDOVolume", (gpointer) (guintptr) (UDISKS_TYPE_VDO_VOLUME_PROXY));
      g_once_init_leave (&once_init_value, 1);
    }
  ret = (GType) (guintptr) (g_hash_table_lookup (lookup_hash, interface_name));
  if (ret == (GType) 0)
    ret = G_TYPE_DBUS_PROXY;
  return ret;
}

/**
 * udisks_object_manager_client_new:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusObjectManagerClientFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Asynchronously creates #GDBusObjectManagerClient using udisks_object_manager_client_get_proxy_type() as the #GDBusProxyTypeFunc. See g_dbus_object_manager_client_new() for more details.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_object_manager_client_new_finish() to get the result of the operation.
 *
 * See udisks_object_manager_client_new_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_object_manager_client_new (
    GDBusConnection        *connection,
    GDBusObjectManagerClientFlags  flags,
    const gchar            *name,
    const gchar            *object_path,
    GCancellable           *cancellable,
    GAsyncReadyCallback     callback,
    gpointer                user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_OBJECT_MANAGER_CLIENT, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "flags", flags, "name", name, "connection", connection, "object-path", object_path, "get-proxy-type-func", udisks_object_manager_client_get_proxy_type, NULL);
}

/**
 * udisks_object_manager_client_new_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_object_manager_client_new().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_object_manager_client_new().
 *
 * Returns: (transfer full) (type UDisksObjectManagerClient): The constructed object manager client or %NULL if @error is set.
 */
GDBusObjectManager *
udisks_object_manager_client_new_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return G_DBUS_OBJECT_MANAGER (ret);
  else
    return NULL;
}

/**
 * udisks_object_manager_client_new_sync:
 * @connection: A #GDBusConnection.
 * @flags: Flags from the #GDBusObjectManagerClientFlags enumeration.
 * @name: (nullable): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Synchronously creates #GDBusObjectManagerClient using udisks_object_manager_client_get_proxy_type() as the #GDBusProxyTypeFunc. See g_dbus_object_manager_client_new_sync() for more details.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_object_manager_client_new() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksObjectManagerClient): The constructed object manager client or %NULL if @error is set.
 */
GDBusObjectManager *
udisks_object_manager_client_new_sync (
    GDBusConnection        *connection,
    GDBusObjectManagerClientFlags  flags,
    const gchar            *name,
    const gchar            *object_path,
    GCancellable           *cancellable,
    GError                **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_OBJECT_MANAGER_CLIENT, cancellable, error, "flags", flags, "name", name, "connection", connection, "object-path", object_path, "get-proxy-type-func", udisks_object_manager_client_get_proxy_type, NULL);
  if (ret != NULL)
    return G_DBUS_OBJECT_MANAGER (ret);
  else
    return NULL;
}


/**
 * udisks_object_manager_client_new_for_bus:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusObjectManagerClientFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
 * @user_data: User data to pass to @callback.
 *
 * Like udisks_object_manager_client_new() but takes a #GBusType instead of a #GDBusConnection.
 *
 * When the operation is finished, @callback will be invoked in the thread-default main loop of the thread you are calling this method from (see g_main_context_push_thread_default()).
 * You can then call udisks_object_manager_client_new_for_bus_finish() to get the result of the operation.
 *
 * See udisks_object_manager_client_new_for_bus_sync() for the synchronous, blocking version of this constructor.
 */
void
udisks_object_manager_client_new_for_bus (
    GBusType                bus_type,
    GDBusObjectManagerClientFlags  flags,
    const gchar            *name,
    const gchar            *object_path,
    GCancellable           *cancellable,
    GAsyncReadyCallback     callback,
    gpointer                user_data)
{
  g_async_initable_new_async (UDISKS_TYPE_OBJECT_MANAGER_CLIENT, G_PRIORITY_DEFAULT, cancellable, callback, user_data, "flags", flags, "name", name, "bus-type", bus_type, "object-path", object_path, "get-proxy-type-func", udisks_object_manager_client_get_proxy_type, NULL);
}

/**
 * udisks_object_manager_client_new_for_bus_finish:
 * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to udisks_object_manager_client_new_for_bus().
 * @error: Return location for error or %NULL
 *
 * Finishes an operation started with udisks_object_manager_client_new_for_bus().
 *
 * Returns: (transfer full) (type UDisksObjectManagerClient): The constructed object manager client or %NULL if @error is set.
 */
GDBusObjectManager *
udisks_object_manager_client_new_for_bus_finish (
    GAsyncResult        *res,
    GError             **error)
{
  GObject *ret;
  GObject *source_object;
  source_object = g_async_result_get_source_object (res);
  ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
  g_object_unref (source_object);
  if (ret != NULL)
    return G_DBUS_OBJECT_MANAGER (ret);
  else
    return NULL;
}

/**
 * udisks_object_manager_client_new_for_bus_sync:
 * @bus_type: A #GBusType.
 * @flags: Flags from the #GDBusObjectManagerClientFlags enumeration.
 * @name: A bus name (well-known or unique).
 * @object_path: An object path.
 * @cancellable: (nullable): A #GCancellable or %NULL.
 * @error: Return location for error or %NULL
 *
 * Like udisks_object_manager_client_new_sync() but takes a #GBusType instead of a #GDBusConnection.
 *
 * The calling thread is blocked until a reply is received.
 *
 * See udisks_object_manager_client_new_for_bus() for the asynchronous version of this constructor.
 *
 * Returns: (transfer full) (type UDisksObjectManagerClient): The constructed object manager client or %NULL if @error is set.
 */
GDBusObjectManager *
udisks_object_manager_client_new_for_bus_sync (
    GBusType                bus_type,
    GDBusObjectManagerClientFlags  flags,
    const gchar            *name,
    const gchar            *object_path,
    GCancellable           *cancellable,
    GError                **error)
{
  GInitable *ret;
  ret = g_initable_new (UDISKS_TYPE_OBJECT_MANAGER_CLIENT, cancellable, error, "flags", flags, "name", name, "bus-type", bus_type, "object-path", object_path, "get-proxy-type-func", udisks_object_manager_client_get_proxy_type, NULL);
  if (ret != NULL)
    return G_DBUS_OBJECT_MANAGER (ret);
  else
    return NULL;
}


