binding/gdbus/udisks_interface.c

   1 /*
   2  * Generated by gdbus-codegen 2.52.0. DO NOT EDIT.
   3  *
   4  * The license of this code is the same as for the source it was derived from.
   5  */
   6
   7 #ifdef HAVE_CONFIG_H
   8 #  include "config.h"
   9 #endif
  10
  11 #include "udisks_interface.h"
  12
  13 #include <string.h>
  14 #ifdef G_OS_UNIX
  15 #  include <gio/gunixfdlist.h>
  16 #endif
  17
  18 typedef struct
  19 {
  20   GDBusArgInfo parent_struct;
  21   gboolean use_gvariant;
  22 } _ExtendedGDBusArgInfo;
  23
  24 typedef struct
  25 {
  26   GDBusMethodInfo parent_struct;
  27   const gchar *signal_name;
  28   gboolean pass_fdlist;
  29 } _ExtendedGDBusMethodInfo;
  30
  31 typedef struct
  32 {
  33   GDBusSignalInfo parent_struct;
  34   const gchar *signal_name;
  35 } _ExtendedGDBusSignalInfo;
  36
  37 typedef struct
  38 {
  39   GDBusPropertyInfo parent_struct;
  40   const gchar *hyphen_name;
  41   gboolean use_gvariant;
  42 } _ExtendedGDBusPropertyInfo;
  43
  44 typedef struct
  45 {
  46   GDBusInterfaceInfo parent_struct;
  47   const gchar *hyphen_name;
  48 } _ExtendedGDBusInterfaceInfo;
  49
  50 typedef struct
  51 {
  52   const _ExtendedGDBusPropertyInfo *info;
  53   guint prop_id;
  54   GValue orig_value; /* the value before the change */
  55 } ChangedProperty;
  56
  57 static void
  58 _changed_property_free (ChangedProperty *data)
  59 {
  60   g_value_unset (&data->orig_value);
  61   g_free (data);
  62 }
  63
  64 static gboolean
  65 _g_strv_equal0 (gchar **a, gchar **b)
  66 {
  67   gboolean ret = FALSE;
  68   guint n;
  69   if (a == NULL && b == NULL)
  70     {
  71       ret = TRUE;
  72       goto out;
  73     }
  74   if (a == NULL || b == NULL)
  75     goto out;
  76   if (g_strv_length (a) != g_strv_length (b))
  77     goto out;
  78   for (n = 0; a[n] != NULL; n++)
  79     if (g_strcmp0 (a[n], b[n]) != 0)
  80       goto out;
  81   ret = TRUE;
  82 out:
  83   return ret;
  84 }
  85
  86 static gboolean
  87 _g_variant_equal0 (GVariant *a, GVariant *b)
  88 {
  89   gboolean ret = FALSE;
  90   if (a == NULL && b == NULL)
  91     {
  92       ret = TRUE;
  93       goto out;
  94     }
  95   if (a == NULL || b == NULL)
  96     goto out;
  97   ret = g_variant_equal (a, b);
  98 out:
  99   return ret;
 100 }
 101
 102 G_GNUC_UNUSED static gboolean
 103 _g_value_equal (const GValue *a, const GValue *b)
 104 {
 105   gboolean ret = FALSE;
 106   g_assert (G_VALUE_TYPE (a) == G_VALUE_TYPE (b));
 107   switch (G_VALUE_TYPE (a))
 108     {
 109       case G_TYPE_BOOLEAN:
 110         ret = (g_value_get_boolean (a) == g_value_get_boolean (b));
 111         break;
 112       case G_TYPE_UCHAR:
 113         ret = (g_value_get_uchar (a) == g_value_get_uchar (b));
 114         break;
 115       case G_TYPE_INT:
 116         ret = (g_value_get_int (a) == g_value_get_int (b));
 117         break;
 118       case G_TYPE_UINT:
 119         ret = (g_value_get_uint (a) == g_value_get_uint (b));
 120         break;
 121       case G_TYPE_INT64:
 122         ret = (g_value_get_int64 (a) == g_value_get_int64 (b));
 123         break;
 124       case G_TYPE_UINT64:
 125         ret = (g_value_get_uint64 (a) == g_value_get_uint64 (b));
 126         break;
 127       case G_TYPE_DOUBLE:
 128         {
 129           /* Avoid -Wfloat-equal warnings by doing a direct bit compare */
 130           gdouble da = g_value_get_double (a);
 131           gdouble db = g_value_get_double (b);
 132           ret = memcmp (&da, &db, sizeof (gdouble)) == 0;
 133         }
 134         break;
 135       case G_TYPE_STRING:
 136         ret = (g_strcmp0 (g_value_get_string (a), g_value_get_string (b)) == 0);
 137         break;
 138       case G_TYPE_VARIANT:
 139         ret = _g_variant_equal0 (g_value_get_variant (a), g_value_get_variant (b));
 140         break;
 141       default:
 142         if (G_VALUE_TYPE (a) == G_TYPE_STRV)
 143           ret = _g_strv_equal0 (g_value_get_boxed (a), g_value_get_boxed (b));
 144         else
 145           g_critical ("_g_value_equal() does not handle type %s", g_type_name (G_VALUE_TYPE (a)));
 146         break;
 147     }
 148   return ret;
 149 }
 150
 151 /* ------------------------------------------------------------------------
 152  * Code for interface org.freedesktop.UDisks
 153  * ------------------------------------------------------------------------
 154  */
 155
 156 /**
 157  * SECTION:OrgFreedesktopUDisks
 158  * @title: OrgFreedesktopUDisks
 159  * @short_description: Generated C code for the org.freedesktop.UDisks D-Bus interface
 160  *
 161  * This section contains code for working with the <link linkend="gdbus-interface-org-freedesktop-UDisks.top_of_page">org.freedesktop.UDisks</link> D-Bus interface in C.
 162  */
 163
 164 /* ---- Introspection data for org.freedesktop.UDisks ---- */
 165
 166 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_enumerate_adapters_OUT_ARG_devices =
 167 {
 168   {
 169     -1,
 170     (gchar *) "devices",
 171     (gchar *) "ao",
 172     NULL
 173   },
 174   FALSE
 175 };
 176
 177 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_enumerate_adapters_OUT_ARG_pointers[] =
 178 {
 179   &_org_freedesktop_udisks_method_info_enumerate_adapters_OUT_ARG_devices,
 180   NULL
 181 };
 182
 183 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_enumerate_adapters_annotation_info_0 =
 184 {
 185   -1,
 186   (gchar *) "org.freedesktop.DBus.GLib.Async",
 187   (gchar *) "",
 188   NULL
 189 };
 190
 191 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_enumerate_adapters_annotation_info_pointers[] =
 192 {
 193   &_org_freedesktop_udisks_method_enumerate_adapters_annotation_info_0,
 194   NULL
 195 };
 196
 197 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_enumerate_adapters =
 198 {
 199   {
 200     -1,
 201     (gchar *) "EnumerateAdapters",
 202     NULL,
 203     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_enumerate_adapters_OUT_ARG_pointers,
 204     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_enumerate_adapters_annotation_info_pointers
 205   },
 206   "handle-enumerate-adapters",
 207   FALSE
 208 };
 209
 210 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_enumerate_expanders_OUT_ARG_devices =
 211 {
 212   {
 213     -1,
 214     (gchar *) "devices",
 215     (gchar *) "ao",
 216     NULL
 217   },
 218   FALSE
 219 };
 220
 221 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_enumerate_expanders_OUT_ARG_pointers[] =
 222 {
 223   &_org_freedesktop_udisks_method_info_enumerate_expanders_OUT_ARG_devices,
 224   NULL
 225 };
 226
 227 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_enumerate_expanders_annotation_info_0 =
 228 {
 229   -1,
 230   (gchar *) "org.freedesktop.DBus.GLib.Async",
 231   (gchar *) "",
 232   NULL
 233 };
 234
 235 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_enumerate_expanders_annotation_info_pointers[] =
 236 {
 237   &_org_freedesktop_udisks_method_enumerate_expanders_annotation_info_0,
 238   NULL
 239 };
 240
 241 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_enumerate_expanders =
 242 {
 243   {
 244     -1,
 245     (gchar *) "EnumerateExpanders",
 246     NULL,
 247     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_enumerate_expanders_OUT_ARG_pointers,
 248     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_enumerate_expanders_annotation_info_pointers
 249   },
 250   "handle-enumerate-expanders",
 251   FALSE
 252 };
 253
 254 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_enumerate_ports_OUT_ARG_devices =
 255 {
 256   {
 257     -1,
 258     (gchar *) "devices",
 259     (gchar *) "ao",
 260     NULL
 261   },
 262   FALSE
 263 };
 264
 265 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_enumerate_ports_OUT_ARG_pointers[] =
 266 {
 267   &_org_freedesktop_udisks_method_info_enumerate_ports_OUT_ARG_devices,
 268   NULL
 269 };
 270
 271 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_enumerate_ports_annotation_info_0 =
 272 {
 273   -1,
 274   (gchar *) "org.freedesktop.DBus.GLib.Async",
 275   (gchar *) "",
 276   NULL
 277 };
 278
 279 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_enumerate_ports_annotation_info_pointers[] =
 280 {
 281   &_org_freedesktop_udisks_method_enumerate_ports_annotation_info_0,
 282   NULL
 283 };
 284
 285 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_enumerate_ports =
 286 {
 287   {
 288     -1,
 289     (gchar *) "EnumeratePorts",
 290     NULL,
 291     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_enumerate_ports_OUT_ARG_pointers,
 292     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_enumerate_ports_annotation_info_pointers
 293   },
 294   "handle-enumerate-ports",
 295   FALSE
 296 };
 297
 298 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_enumerate_devices_OUT_ARG_devices =
 299 {
 300   {
 301     -1,
 302     (gchar *) "devices",
 303     (gchar *) "ao",
 304     NULL
 305   },
 306   FALSE
 307 };
 308
 309 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_enumerate_devices_OUT_ARG_pointers[] =
 310 {
 311   &_org_freedesktop_udisks_method_info_enumerate_devices_OUT_ARG_devices,
 312   NULL
 313 };
 314
 315 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_enumerate_devices_annotation_info_0 =
 316 {
 317   -1,
 318   (gchar *) "org.freedesktop.DBus.GLib.Async",
 319   (gchar *) "",
 320   NULL
 321 };
 322
 323 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_enumerate_devices_annotation_info_pointers[] =
 324 {
 325   &_org_freedesktop_udisks_method_enumerate_devices_annotation_info_0,
 326   NULL
 327 };
 328
 329 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_enumerate_devices =
 330 {
 331   {
 332     -1,
 333     (gchar *) "EnumerateDevices",
 334     NULL,
 335     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_enumerate_devices_OUT_ARG_pointers,
 336     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_enumerate_devices_annotation_info_pointers
 337   },
 338   "handle-enumerate-devices",
 339   FALSE
 340 };
 341
 342 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_enumerate_device_files_OUT_ARG_device_files =
 343 {
 344   {
 345     -1,
 346     (gchar *) "device_files",
 347     (gchar *) "as",
 348     NULL
 349   },
 350   FALSE
 351 };
 352
 353 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_enumerate_device_files_OUT_ARG_pointers[] =
 354 {
 355   &_org_freedesktop_udisks_method_info_enumerate_device_files_OUT_ARG_device_files,
 356   NULL
 357 };
 358
 359 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_enumerate_device_files_annotation_info_0 =
 360 {
 361   -1,
 362   (gchar *) "org.freedesktop.DBus.GLib.Async",
 363   (gchar *) "",
 364   NULL
 365 };
 366
 367 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_enumerate_device_files_annotation_info_pointers[] =
 368 {
 369   &_org_freedesktop_udisks_method_enumerate_device_files_annotation_info_0,
 370   NULL
 371 };
 372
 373 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_enumerate_device_files =
 374 {
 375   {
 376     -1,
 377     (gchar *) "EnumerateDeviceFiles",
 378     NULL,
 379     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_enumerate_device_files_OUT_ARG_pointers,
 380     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_enumerate_device_files_annotation_info_pointers
 381   },
 382   "handle-enumerate-device-files",
 383   FALSE
 384 };
 385
 386 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_find_device_by_device_file_IN_ARG_device_file =
 387 {
 388   {
 389     -1,
 390     (gchar *) "device_file",
 391     (gchar *) "s",
 392     NULL
 393   },
 394   FALSE
 395 };
 396
 397 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_find_device_by_device_file_IN_ARG_pointers[] =
 398 {
 399   &_org_freedesktop_udisks_method_info_find_device_by_device_file_IN_ARG_device_file,
 400   NULL
 401 };
 402
 403 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_find_device_by_device_file_OUT_ARG_device =
 404 {
 405   {
 406     -1,
 407     (gchar *) "device",
 408     (gchar *) "o",
 409     NULL
 410   },
 411   FALSE
 412 };
 413
 414 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_find_device_by_device_file_OUT_ARG_pointers[] =
 415 {
 416   &_org_freedesktop_udisks_method_info_find_device_by_device_file_OUT_ARG_device,
 417   NULL
 418 };
 419
 420 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_find_device_by_device_file_annotation_info_0 =
 421 {
 422   -1,
 423   (gchar *) "org.freedesktop.DBus.GLib.Async",
 424   (gchar *) "",
 425   NULL
 426 };
 427
 428 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_find_device_by_device_file_annotation_info_pointers[] =
 429 {
 430   &_org_freedesktop_udisks_method_find_device_by_device_file_annotation_info_0,
 431   NULL
 432 };
 433
 434 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_find_device_by_device_file =
 435 {
 436   {
 437     -1,
 438     (gchar *) "FindDeviceByDeviceFile",
 439     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_find_device_by_device_file_IN_ARG_pointers,
 440     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_find_device_by_device_file_OUT_ARG_pointers,
 441     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_find_device_by_device_file_annotation_info_pointers
 442   },
 443   "handle-find-device-by-device-file",
 444   FALSE
 445 };
 446
 447 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_find_device_by_major_minor_IN_ARG_device_major =
 448 {
 449   {
 450     -1,
 451     (gchar *) "device_major",
 452     (gchar *) "x",
 453     NULL
 454   },
 455   FALSE
 456 };
 457
 458 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_find_device_by_major_minor_IN_ARG_device_minor =
 459 {
 460   {
 461     -1,
 462     (gchar *) "device_minor",
 463     (gchar *) "x",
 464     NULL
 465   },
 466   FALSE
 467 };
 468
 469 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_find_device_by_major_minor_IN_ARG_pointers[] =
 470 {
 471   &_org_freedesktop_udisks_method_info_find_device_by_major_minor_IN_ARG_device_major,
 472   &_org_freedesktop_udisks_method_info_find_device_by_major_minor_IN_ARG_device_minor,
 473   NULL
 474 };
 475
 476 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_find_device_by_major_minor_OUT_ARG_device =
 477 {
 478   {
 479     -1,
 480     (gchar *) "device",
 481     (gchar *) "o",
 482     NULL
 483   },
 484   FALSE
 485 };
 486
 487 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_find_device_by_major_minor_OUT_ARG_pointers[] =
 488 {
 489   &_org_freedesktop_udisks_method_info_find_device_by_major_minor_OUT_ARG_device,
 490   NULL
 491 };
 492
 493 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_find_device_by_major_minor_annotation_info_0 =
 494 {
 495   -1,
 496   (gchar *) "org.freedesktop.DBus.GLib.Async",
 497   (gchar *) "",
 498   NULL
 499 };
 500
 501 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_find_device_by_major_minor_annotation_info_pointers[] =
 502 {
 503   &_org_freedesktop_udisks_method_find_device_by_major_minor_annotation_info_0,
 504   NULL
 505 };
 506
 507 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_find_device_by_major_minor =
 508 {
 509   {
 510     -1,
 511     (gchar *) "FindDeviceByMajorMinor",
 512     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_find_device_by_major_minor_IN_ARG_pointers,
 513     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_find_device_by_major_minor_OUT_ARG_pointers,
 514     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_find_device_by_major_minor_annotation_info_pointers
 515   },
 516   "handle-find-device-by-major-minor",
 517   FALSE
 518 };
 519
 520 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_drive_inhibit_all_polling_IN_ARG_options =
 521 {
 522   {
 523     -1,
 524     (gchar *) "options",
 525     (gchar *) "as",
 526     NULL
 527   },
 528   FALSE
 529 };
 530
 531 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_drive_inhibit_all_polling_IN_ARG_pointers[] =
 532 {
 533   &_org_freedesktop_udisks_method_info_drive_inhibit_all_polling_IN_ARG_options,
 534   NULL
 535 };
 536
 537 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_drive_inhibit_all_polling_OUT_ARG_cookie =
 538 {
 539   {
 540     -1,
 541     (gchar *) "cookie",
 542     (gchar *) "s",
 543     NULL
 544   },
 545   FALSE
 546 };
 547
 548 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_drive_inhibit_all_polling_OUT_ARG_pointers[] =
 549 {
 550   &_org_freedesktop_udisks_method_info_drive_inhibit_all_polling_OUT_ARG_cookie,
 551   NULL
 552 };
 553
 554 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_drive_inhibit_all_polling_annotation_info_0 =
 555 {
 556   -1,
 557   (gchar *) "org.freedesktop.DBus.GLib.Async",
 558   (gchar *) "",
 559   NULL
 560 };
 561
 562 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_drive_inhibit_all_polling_annotation_info_pointers[] =
 563 {
 564   &_org_freedesktop_udisks_method_drive_inhibit_all_polling_annotation_info_0,
 565   NULL
 566 };
 567
 568 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_drive_inhibit_all_polling =
 569 {
 570   {
 571     -1,
 572     (gchar *) "DriveInhibitAllPolling",
 573     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_drive_inhibit_all_polling_IN_ARG_pointers,
 574     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_drive_inhibit_all_polling_OUT_ARG_pointers,
 575     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_drive_inhibit_all_polling_annotation_info_pointers
 576   },
 577   "handle-drive-inhibit-all-polling",
 578   FALSE
 579 };
 580
 581 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_drive_uninhibit_all_polling_IN_ARG_cookie =
 582 {
 583   {
 584     -1,
 585     (gchar *) "cookie",
 586     (gchar *) "s",
 587     NULL
 588   },
 589   FALSE
 590 };
 591
 592 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_drive_uninhibit_all_polling_IN_ARG_pointers[] =
 593 {
 594   &_org_freedesktop_udisks_method_info_drive_uninhibit_all_polling_IN_ARG_cookie,
 595   NULL
 596 };
 597
 598 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_drive_uninhibit_all_polling_annotation_info_0 =
 599 {
 600   -1,
 601   (gchar *) "org.freedesktop.DBus.GLib.Async",
 602   (gchar *) "",
 603   NULL
 604 };
 605
 606 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_drive_uninhibit_all_polling_annotation_info_pointers[] =
 607 {
 608   &_org_freedesktop_udisks_method_drive_uninhibit_all_polling_annotation_info_0,
 609   NULL
 610 };
 611
 612 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_drive_uninhibit_all_polling =
 613 {
 614   {
 615     -1,
 616     (gchar *) "DriveUninhibitAllPolling",
 617     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_drive_uninhibit_all_polling_IN_ARG_pointers,
 618     NULL,
 619     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_drive_uninhibit_all_polling_annotation_info_pointers
 620   },
 621   "handle-drive-uninhibit-all-polling",
 622   FALSE
 623 };
 624
 625 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_drive_set_all_spindown_timeouts_IN_ARG_timeout_seconds =
 626 {
 627   {
 628     -1,
 629     (gchar *) "timeout_seconds",
 630     (gchar *) "i",
 631     NULL
 632   },
 633   FALSE
 634 };
 635
 636 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_drive_set_all_spindown_timeouts_IN_ARG_options =
 637 {
 638   {
 639     -1,
 640     (gchar *) "options",
 641     (gchar *) "as",
 642     NULL
 643   },
 644   FALSE
 645 };
 646
 647 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_drive_set_all_spindown_timeouts_IN_ARG_pointers[] =
 648 {
 649   &_org_freedesktop_udisks_method_info_drive_set_all_spindown_timeouts_IN_ARG_timeout_seconds,
 650   &_org_freedesktop_udisks_method_info_drive_set_all_spindown_timeouts_IN_ARG_options,
 651   NULL
 652 };
 653
 654 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_drive_set_all_spindown_timeouts_OUT_ARG_cookie =
 655 {
 656   {
 657     -1,
 658     (gchar *) "cookie",
 659     (gchar *) "s",
 660     NULL
 661   },
 662   FALSE
 663 };
 664
 665 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_drive_set_all_spindown_timeouts_OUT_ARG_pointers[] =
 666 {
 667   &_org_freedesktop_udisks_method_info_drive_set_all_spindown_timeouts_OUT_ARG_cookie,
 668   NULL
 669 };
 670
 671 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_drive_set_all_spindown_timeouts_annotation_info_0 =
 672 {
 673   -1,
 674   (gchar *) "org.freedesktop.DBus.GLib.Async",
 675   (gchar *) "",
 676   NULL
 677 };
 678
 679 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_drive_set_all_spindown_timeouts_annotation_info_pointers[] =
 680 {
 681   &_org_freedesktop_udisks_method_drive_set_all_spindown_timeouts_annotation_info_0,
 682   NULL
 683 };
 684
 685 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_drive_set_all_spindown_timeouts =
 686 {
 687   {
 688     -1,
 689     (gchar *) "DriveSetAllSpindownTimeouts",
 690     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_drive_set_all_spindown_timeouts_IN_ARG_pointers,
 691     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_drive_set_all_spindown_timeouts_OUT_ARG_pointers,
 692     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_drive_set_all_spindown_timeouts_annotation_info_pointers
 693   },
 694   "handle-drive-set-all-spindown-timeouts",
 695   FALSE
 696 };
 697
 698 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_drive_unset_all_spindown_timeouts_IN_ARG_cookie =
 699 {
 700   {
 701     -1,
 702     (gchar *) "cookie",
 703     (gchar *) "s",
 704     NULL
 705   },
 706   FALSE
 707 };
 708
 709 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_drive_unset_all_spindown_timeouts_IN_ARG_pointers[] =
 710 {
 711   &_org_freedesktop_udisks_method_info_drive_unset_all_spindown_timeouts_IN_ARG_cookie,
 712   NULL
 713 };
 714
 715 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_drive_unset_all_spindown_timeouts_annotation_info_0 =
 716 {
 717   -1,
 718   (gchar *) "org.freedesktop.DBus.GLib.Async",
 719   (gchar *) "",
 720   NULL
 721 };
 722
 723 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_drive_unset_all_spindown_timeouts_annotation_info_pointers[] =
 724 {
 725   &_org_freedesktop_udisks_method_drive_unset_all_spindown_timeouts_annotation_info_0,
 726   NULL
 727 };
 728
 729 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_drive_unset_all_spindown_timeouts =
 730 {
 731   {
 732     -1,
 733     (gchar *) "DriveUnsetAllSpindownTimeouts",
 734     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_drive_unset_all_spindown_timeouts_IN_ARG_pointers,
 735     NULL,
 736     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_drive_unset_all_spindown_timeouts_annotation_info_pointers
 737   },
 738   "handle-drive-unset-all-spindown-timeouts",
 739   FALSE
 740 };
 741
 742 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgstart_IN_ARG_uuid =
 743 {
 744   {
 745     -1,
 746     (gchar *) "uuid",
 747     (gchar *) "s",
 748     NULL
 749   },
 750   FALSE
 751 };
 752
 753 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgstart_IN_ARG_options =
 754 {
 755   {
 756     -1,
 757     (gchar *) "options",
 758     (gchar *) "as",
 759     NULL
 760   },
 761   FALSE
 762 };
 763
 764 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_lvm2_vgstart_IN_ARG_pointers[] =
 765 {
 766   &_org_freedesktop_udisks_method_info_linux_lvm2_vgstart_IN_ARG_uuid,
 767   &_org_freedesktop_udisks_method_info_linux_lvm2_vgstart_IN_ARG_options,
 768   NULL
 769 };
 770
 771 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_linux_lvm2_vgstart_annotation_info_0 =
 772 {
 773   -1,
 774   (gchar *) "org.freedesktop.DBus.GLib.Async",
 775   (gchar *) "",
 776   NULL
 777 };
 778
 779 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_linux_lvm2_vgstart_annotation_info_pointers[] =
 780 {
 781   &_org_freedesktop_udisks_method_linux_lvm2_vgstart_annotation_info_0,
 782   NULL
 783 };
 784
 785 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgstart =
 786 {
 787   {
 788     -1,
 789     (gchar *) "LinuxLvm2VGStart",
 790     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_lvm2_vgstart_IN_ARG_pointers,
 791     NULL,
 792     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_linux_lvm2_vgstart_annotation_info_pointers
 793   },
 794   "handle-linux-lvm2-vgstart",
 795   FALSE
 796 };
 797
 798 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgstop_IN_ARG_uuid =
 799 {
 800   {
 801     -1,
 802     (gchar *) "uuid",
 803     (gchar *) "s",
 804     NULL
 805   },
 806   FALSE
 807 };
 808
 809 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgstop_IN_ARG_options =
 810 {
 811   {
 812     -1,
 813     (gchar *) "options",
 814     (gchar *) "as",
 815     NULL
 816   },
 817   FALSE
 818 };
 819
 820 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_lvm2_vgstop_IN_ARG_pointers[] =
 821 {
 822   &_org_freedesktop_udisks_method_info_linux_lvm2_vgstop_IN_ARG_uuid,
 823   &_org_freedesktop_udisks_method_info_linux_lvm2_vgstop_IN_ARG_options,
 824   NULL
 825 };
 826
 827 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_linux_lvm2_vgstop_annotation_info_0 =
 828 {
 829   -1,
 830   (gchar *) "org.freedesktop.DBus.GLib.Async",
 831   (gchar *) "",
 832   NULL
 833 };
 834
 835 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_linux_lvm2_vgstop_annotation_info_pointers[] =
 836 {
 837   &_org_freedesktop_udisks_method_linux_lvm2_vgstop_annotation_info_0,
 838   NULL
 839 };
 840
 841 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgstop =
 842 {
 843   {
 844     -1,
 845     (gchar *) "LinuxLvm2VGStop",
 846     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_lvm2_vgstop_IN_ARG_pointers,
 847     NULL,
 848     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_linux_lvm2_vgstop_annotation_info_pointers
 849   },
 850   "handle-linux-lvm2-vgstop",
 851   FALSE
 852 };
 853
 854 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgset_name_IN_ARG_uuid =
 855 {
 856   {
 857     -1,
 858     (gchar *) "uuid",
 859     (gchar *) "s",
 860     NULL
 861   },
 862   FALSE
 863 };
 864
 865 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgset_name_IN_ARG_name =
 866 {
 867   {
 868     -1,
 869     (gchar *) "name",
 870     (gchar *) "s",
 871     NULL
 872   },
 873   FALSE
 874 };
 875
 876 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_lvm2_vgset_name_IN_ARG_pointers[] =
 877 {
 878   &_org_freedesktop_udisks_method_info_linux_lvm2_vgset_name_IN_ARG_uuid,
 879   &_org_freedesktop_udisks_method_info_linux_lvm2_vgset_name_IN_ARG_name,
 880   NULL
 881 };
 882
 883 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_linux_lvm2_vgset_name_annotation_info_0 =
 884 {
 885   -1,
 886   (gchar *) "org.freedesktop.DBus.GLib.Async",
 887   (gchar *) "",
 888   NULL
 889 };
 890
 891 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_linux_lvm2_vgset_name_annotation_info_pointers[] =
 892 {
 893   &_org_freedesktop_udisks_method_linux_lvm2_vgset_name_annotation_info_0,
 894   NULL
 895 };
 896
 897 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgset_name =
 898 {
 899   {
 900     -1,
 901     (gchar *) "LinuxLvm2VGSetName",
 902     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_lvm2_vgset_name_IN_ARG_pointers,
 903     NULL,
 904     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_linux_lvm2_vgset_name_annotation_info_pointers
 905   },
 906   "handle-linux-lvm2-vgset-name",
 907   FALSE
 908 };
 909
 910 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgadd_pv_IN_ARG_uuid =
 911 {
 912   {
 913     -1,
 914     (gchar *) "uuid",
 915     (gchar *) "s",
 916     NULL
 917   },
 918   FALSE
 919 };
 920
 921 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgadd_pv_IN_ARG_physical_volume =
 922 {
 923   {
 924     -1,
 925     (gchar *) "physical_volume",
 926     (gchar *) "o",
 927     NULL
 928   },
 929   FALSE
 930 };
 931
 932 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgadd_pv_IN_ARG_options =
 933 {
 934   {
 935     -1,
 936     (gchar *) "options",
 937     (gchar *) "as",
 938     NULL
 939   },
 940   FALSE
 941 };
 942
 943 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_lvm2_vgadd_pv_IN_ARG_pointers[] =
 944 {
 945   &_org_freedesktop_udisks_method_info_linux_lvm2_vgadd_pv_IN_ARG_uuid,
 946   &_org_freedesktop_udisks_method_info_linux_lvm2_vgadd_pv_IN_ARG_physical_volume,
 947   &_org_freedesktop_udisks_method_info_linux_lvm2_vgadd_pv_IN_ARG_options,
 948   NULL
 949 };
 950
 951 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_linux_lvm2_vgadd_pv_annotation_info_0 =
 952 {
 953   -1,
 954   (gchar *) "org.freedesktop.DBus.GLib.Async",
 955   (gchar *) "",
 956   NULL
 957 };
 958
 959 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_linux_lvm2_vgadd_pv_annotation_info_pointers[] =
 960 {
 961   &_org_freedesktop_udisks_method_linux_lvm2_vgadd_pv_annotation_info_0,
 962   NULL
 963 };
 964
 965 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgadd_pv =
 966 {
 967   {
 968     -1,
 969     (gchar *) "LinuxLvm2VGAddPV",
 970     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_lvm2_vgadd_pv_IN_ARG_pointers,
 971     NULL,
 972     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_linux_lvm2_vgadd_pv_annotation_info_pointers
 973   },
 974   "handle-linux-lvm2-vgadd-pv",
 975   FALSE
 976 };
 977
 978 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgremove_pv_IN_ARG_vg_uuid =
 979 {
 980   {
 981     -1,
 982     (gchar *) "vg_uuid",
 983     (gchar *) "s",
 984     NULL
 985   },
 986   FALSE
 987 };
 988
 989 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgremove_pv_IN_ARG_pv_uuid =
 990 {
 991   {
 992     -1,
 993     (gchar *) "pv_uuid",
 994     (gchar *) "s",
 995     NULL
 996   },
 997   FALSE
 998 };
 999
1000 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgremove_pv_IN_ARG_options =
1001 {
1002   {
1003     -1,
1004     (gchar *) "options",
1005     (gchar *) "as",
1006     NULL
1007   },
1008   FALSE
1009 };
1010
1011 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_lvm2_vgremove_pv_IN_ARG_pointers[] =
1012 {
1013   &_org_freedesktop_udisks_method_info_linux_lvm2_vgremove_pv_IN_ARG_vg_uuid,
1014   &_org_freedesktop_udisks_method_info_linux_lvm2_vgremove_pv_IN_ARG_pv_uuid,
1015   &_org_freedesktop_udisks_method_info_linux_lvm2_vgremove_pv_IN_ARG_options,
1016   NULL
1017 };
1018
1019 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_linux_lvm2_vgremove_pv_annotation_info_0 =
1020 {
1021   -1,
1022   (gchar *) "org.freedesktop.DBus.GLib.Async",
1023   (gchar *) "",
1024   NULL
1025 };
1026
1027 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_linux_lvm2_vgremove_pv_annotation_info_pointers[] =
1028 {
1029   &_org_freedesktop_udisks_method_linux_lvm2_vgremove_pv_annotation_info_0,
1030   NULL
1031 };
1032
1033 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_linux_lvm2_vgremove_pv =
1034 {
1035   {
1036     -1,
1037     (gchar *) "LinuxLvm2VGRemovePV",
1038     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_lvm2_vgremove_pv_IN_ARG_pointers,
1039     NULL,
1040     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_linux_lvm2_vgremove_pv_annotation_info_pointers
1041   },
1042   "handle-linux-lvm2-vgremove-pv",
1043   FALSE
1044 };
1045
1046 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvset_name_IN_ARG_group_uuid =
1047 {
1048   {
1049     -1,
1050     (gchar *) "group_uuid",
1051     (gchar *) "s",
1052     NULL
1053   },
1054   FALSE
1055 };
1056
1057 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvset_name_IN_ARG_uuid =
1058 {
1059   {
1060     -1,
1061     (gchar *) "uuid",
1062     (gchar *) "s",
1063     NULL
1064   },
1065   FALSE
1066 };
1067
1068 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvset_name_IN_ARG_name =
1069 {
1070   {
1071     -1,
1072     (gchar *) "name",
1073     (gchar *) "s",
1074     NULL
1075   },
1076   FALSE
1077 };
1078
1079 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_lvm2_lvset_name_IN_ARG_pointers[] =
1080 {
1081   &_org_freedesktop_udisks_method_info_linux_lvm2_lvset_name_IN_ARG_group_uuid,
1082   &_org_freedesktop_udisks_method_info_linux_lvm2_lvset_name_IN_ARG_uuid,
1083   &_org_freedesktop_udisks_method_info_linux_lvm2_lvset_name_IN_ARG_name,
1084   NULL
1085 };
1086
1087 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_linux_lvm2_lvset_name_annotation_info_0 =
1088 {
1089   -1,
1090   (gchar *) "org.freedesktop.DBus.GLib.Async",
1091   (gchar *) "",
1092   NULL
1093 };
1094
1095 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_linux_lvm2_lvset_name_annotation_info_pointers[] =
1096 {
1097   &_org_freedesktop_udisks_method_linux_lvm2_lvset_name_annotation_info_0,
1098   NULL
1099 };
1100
1101 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvset_name =
1102 {
1103   {
1104     -1,
1105     (gchar *) "LinuxLvm2LVSetName",
1106     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_lvm2_lvset_name_IN_ARG_pointers,
1107     NULL,
1108     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_linux_lvm2_lvset_name_annotation_info_pointers
1109   },
1110   "handle-linux-lvm2-lvset-name",
1111   FALSE
1112 };
1113
1114 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvstart_IN_ARG_group_uuid =
1115 {
1116   {
1117     -1,
1118     (gchar *) "group_uuid",
1119     (gchar *) "s",
1120     NULL
1121   },
1122   FALSE
1123 };
1124
1125 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvstart_IN_ARG_uuid =
1126 {
1127   {
1128     -1,
1129     (gchar *) "uuid",
1130     (gchar *) "s",
1131     NULL
1132   },
1133   FALSE
1134 };
1135
1136 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvstart_IN_ARG_options =
1137 {
1138   {
1139     -1,
1140     (gchar *) "options",
1141     (gchar *) "as",
1142     NULL
1143   },
1144   FALSE
1145 };
1146
1147 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_lvm2_lvstart_IN_ARG_pointers[] =
1148 {
1149   &_org_freedesktop_udisks_method_info_linux_lvm2_lvstart_IN_ARG_group_uuid,
1150   &_org_freedesktop_udisks_method_info_linux_lvm2_lvstart_IN_ARG_uuid,
1151   &_org_freedesktop_udisks_method_info_linux_lvm2_lvstart_IN_ARG_options,
1152   NULL
1153 };
1154
1155 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_linux_lvm2_lvstart_annotation_info_0 =
1156 {
1157   -1,
1158   (gchar *) "org.freedesktop.DBus.GLib.Async",
1159   (gchar *) "",
1160   NULL
1161 };
1162
1163 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_linux_lvm2_lvstart_annotation_info_pointers[] =
1164 {
1165   &_org_freedesktop_udisks_method_linux_lvm2_lvstart_annotation_info_0,
1166   NULL
1167 };
1168
1169 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvstart =
1170 {
1171   {
1172     -1,
1173     (gchar *) "LinuxLvm2LVStart",
1174     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_lvm2_lvstart_IN_ARG_pointers,
1175     NULL,
1176     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_linux_lvm2_lvstart_annotation_info_pointers
1177   },
1178   "handle-linux-lvm2-lvstart",
1179   FALSE
1180 };
1181
1182 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvremove_IN_ARG_group_uuid =
1183 {
1184   {
1185     -1,
1186     (gchar *) "group_uuid",
1187     (gchar *) "s",
1188     NULL
1189   },
1190   FALSE
1191 };
1192
1193 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvremove_IN_ARG_uuid =
1194 {
1195   {
1196     -1,
1197     (gchar *) "uuid",
1198     (gchar *) "s",
1199     NULL
1200   },
1201   FALSE
1202 };
1203
1204 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvremove_IN_ARG_options =
1205 {
1206   {
1207     -1,
1208     (gchar *) "options",
1209     (gchar *) "as",
1210     NULL
1211   },
1212   FALSE
1213 };
1214
1215 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_lvm2_lvremove_IN_ARG_pointers[] =
1216 {
1217   &_org_freedesktop_udisks_method_info_linux_lvm2_lvremove_IN_ARG_group_uuid,
1218   &_org_freedesktop_udisks_method_info_linux_lvm2_lvremove_IN_ARG_uuid,
1219   &_org_freedesktop_udisks_method_info_linux_lvm2_lvremove_IN_ARG_options,
1220   NULL
1221 };
1222
1223 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_linux_lvm2_lvremove_annotation_info_0 =
1224 {
1225   -1,
1226   (gchar *) "org.freedesktop.DBus.GLib.Async",
1227   (gchar *) "",
1228   NULL
1229 };
1230
1231 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_linux_lvm2_lvremove_annotation_info_pointers[] =
1232 {
1233   &_org_freedesktop_udisks_method_linux_lvm2_lvremove_annotation_info_0,
1234   NULL
1235 };
1236
1237 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvremove =
1238 {
1239   {
1240     -1,
1241     (gchar *) "LinuxLvm2LVRemove",
1242     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_lvm2_lvremove_IN_ARG_pointers,
1243     NULL,
1244     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_linux_lvm2_lvremove_annotation_info_pointers
1245   },
1246   "handle-linux-lvm2-lvremove",
1247   FALSE
1248 };
1249
1250 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_group_uuid =
1251 {
1252   {
1253     -1,
1254     (gchar *) "group_uuid",
1255     (gchar *) "s",
1256     NULL
1257   },
1258   FALSE
1259 };
1260
1261 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_name =
1262 {
1263   {
1264     -1,
1265     (gchar *) "name",
1266     (gchar *) "s",
1267     NULL
1268   },
1269   FALSE
1270 };
1271
1272 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_size =
1273 {
1274   {
1275     -1,
1276     (gchar *) "size",
1277     (gchar *) "t",
1278     NULL
1279   },
1280   FALSE
1281 };
1282
1283 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_num_stripes =
1284 {
1285   {
1286     -1,
1287     (gchar *) "num_stripes",
1288     (gchar *) "u",
1289     NULL
1290   },
1291   FALSE
1292 };
1293
1294 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_stripe_size =
1295 {
1296   {
1297     -1,
1298     (gchar *) "stripe_size",
1299     (gchar *) "t",
1300     NULL
1301   },
1302   FALSE
1303 };
1304
1305 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_num_mirrors =
1306 {
1307   {
1308     -1,
1309     (gchar *) "num_mirrors",
1310     (gchar *) "u",
1311     NULL
1312   },
1313   FALSE
1314 };
1315
1316 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_options =
1317 {
1318   {
1319     -1,
1320     (gchar *) "options",
1321     (gchar *) "as",
1322     NULL
1323   },
1324   FALSE
1325 };
1326
1327 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_fstype =
1328 {
1329   {
1330     -1,
1331     (gchar *) "fstype",
1332     (gchar *) "s",
1333     NULL
1334   },
1335   FALSE
1336 };
1337
1338 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_fsoptions =
1339 {
1340   {
1341     -1,
1342     (gchar *) "fsoptions",
1343     (gchar *) "as",
1344     NULL
1345   },
1346   FALSE
1347 };
1348
1349 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_pointers[] =
1350 {
1351   &_org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_group_uuid,
1352   &_org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_name,
1353   &_org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_size,
1354   &_org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_num_stripes,
1355   &_org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_stripe_size,
1356   &_org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_num_mirrors,
1357   &_org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_options,
1358   &_org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_fstype,
1359   &_org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_fsoptions,
1360   NULL
1361 };
1362
1363 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_OUT_ARG_created_device =
1364 {
1365   {
1366     -1,
1367     (gchar *) "created_device",
1368     (gchar *) "o",
1369     NULL
1370   },
1371   FALSE
1372 };
1373
1374 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_OUT_ARG_pointers[] =
1375 {
1376   &_org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_OUT_ARG_created_device,
1377   NULL
1378 };
1379
1380 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_linux_lvm2_lvcreate_annotation_info_0 =
1381 {
1382   -1,
1383   (gchar *) "org.freedesktop.DBus.GLib.Async",
1384   (gchar *) "",
1385   NULL
1386 };
1387
1388 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_linux_lvm2_lvcreate_annotation_info_pointers[] =
1389 {
1390   &_org_freedesktop_udisks_method_linux_lvm2_lvcreate_annotation_info_0,
1391   NULL
1392 };
1393
1394 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_linux_lvm2_lvcreate =
1395 {
1396   {
1397     -1,
1398     (gchar *) "LinuxLvm2LVCreate",
1399     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_IN_ARG_pointers,
1400     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_lvm2_lvcreate_OUT_ARG_pointers,
1401     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_linux_lvm2_lvcreate_annotation_info_pointers
1402   },
1403   "handle-linux-lvm2-lvcreate",
1404   FALSE
1405 };
1406
1407 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_md_start_IN_ARG_components =
1408 {
1409   {
1410     -1,
1411     (gchar *) "components",
1412     (gchar *) "ao",
1413     NULL
1414   },
1415   FALSE
1416 };
1417
1418 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_md_start_IN_ARG_options =
1419 {
1420   {
1421     -1,
1422     (gchar *) "options",
1423     (gchar *) "as",
1424     NULL
1425   },
1426   FALSE
1427 };
1428
1429 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_md_start_IN_ARG_pointers[] =
1430 {
1431   &_org_freedesktop_udisks_method_info_linux_md_start_IN_ARG_components,
1432   &_org_freedesktop_udisks_method_info_linux_md_start_IN_ARG_options,
1433   NULL
1434 };
1435
1436 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_md_start_OUT_ARG_device =
1437 {
1438   {
1439     -1,
1440     (gchar *) "device",
1441     (gchar *) "o",
1442     NULL
1443   },
1444   FALSE
1445 };
1446
1447 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_md_start_OUT_ARG_pointers[] =
1448 {
1449   &_org_freedesktop_udisks_method_info_linux_md_start_OUT_ARG_device,
1450   NULL
1451 };
1452
1453 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_linux_md_start_annotation_info_0 =
1454 {
1455   -1,
1456   (gchar *) "org.freedesktop.DBus.GLib.Async",
1457   (gchar *) "",
1458   NULL
1459 };
1460
1461 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_linux_md_start_annotation_info_pointers[] =
1462 {
1463   &_org_freedesktop_udisks_method_linux_md_start_annotation_info_0,
1464   NULL
1465 };
1466
1467 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_linux_md_start =
1468 {
1469   {
1470     -1,
1471     (gchar *) "LinuxMdStart",
1472     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_md_start_IN_ARG_pointers,
1473     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_md_start_OUT_ARG_pointers,
1474     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_linux_md_start_annotation_info_pointers
1475   },
1476   "handle-linux-md-start",
1477   FALSE
1478 };
1479
1480 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_md_create_IN_ARG_components =
1481 {
1482   {
1483     -1,
1484     (gchar *) "components",
1485     (gchar *) "ao",
1486     NULL
1487   },
1488   FALSE
1489 };
1490
1491 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_md_create_IN_ARG_level =
1492 {
1493   {
1494     -1,
1495     (gchar *) "level",
1496     (gchar *) "s",
1497     NULL
1498   },
1499   FALSE
1500 };
1501
1502 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_md_create_IN_ARG_stripe_size =
1503 {
1504   {
1505     -1,
1506     (gchar *) "stripe_size",
1507     (gchar *) "t",
1508     NULL
1509   },
1510   FALSE
1511 };
1512
1513 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_md_create_IN_ARG_name =
1514 {
1515   {
1516     -1,
1517     (gchar *) "name",
1518     (gchar *) "s",
1519     NULL
1520   },
1521   FALSE
1522 };
1523
1524 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_md_create_IN_ARG_options =
1525 {
1526   {
1527     -1,
1528     (gchar *) "options",
1529     (gchar *) "as",
1530     NULL
1531   },
1532   FALSE
1533 };
1534
1535 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_md_create_IN_ARG_pointers[] =
1536 {
1537   &_org_freedesktop_udisks_method_info_linux_md_create_IN_ARG_components,
1538   &_org_freedesktop_udisks_method_info_linux_md_create_IN_ARG_level,
1539   &_org_freedesktop_udisks_method_info_linux_md_create_IN_ARG_stripe_size,
1540   &_org_freedesktop_udisks_method_info_linux_md_create_IN_ARG_name,
1541   &_org_freedesktop_udisks_method_info_linux_md_create_IN_ARG_options,
1542   NULL
1543 };
1544
1545 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_linux_md_create_OUT_ARG_device =
1546 {
1547   {
1548     -1,
1549     (gchar *) "device",
1550     (gchar *) "o",
1551     NULL
1552   },
1553   FALSE
1554 };
1555
1556 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_linux_md_create_OUT_ARG_pointers[] =
1557 {
1558   &_org_freedesktop_udisks_method_info_linux_md_create_OUT_ARG_device,
1559   NULL
1560 };
1561
1562 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_linux_md_create_annotation_info_0 =
1563 {
1564   -1,
1565   (gchar *) "org.freedesktop.DBus.GLib.Async",
1566   (gchar *) "",
1567   NULL
1568 };
1569
1570 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_linux_md_create_annotation_info_pointers[] =
1571 {
1572   &_org_freedesktop_udisks_method_linux_md_create_annotation_info_0,
1573   NULL
1574 };
1575
1576 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_linux_md_create =
1577 {
1578   {
1579     -1,
1580     (gchar *) "LinuxMdCreate",
1581     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_md_create_IN_ARG_pointers,
1582     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_linux_md_create_OUT_ARG_pointers,
1583     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_linux_md_create_annotation_info_pointers
1584   },
1585   "handle-linux-md-create",
1586   FALSE
1587 };
1588
1589 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_inhibit_OUT_ARG_cookie =
1590 {
1591   {
1592     -1,
1593     (gchar *) "cookie",
1594     (gchar *) "s",
1595     NULL
1596   },
1597   FALSE
1598 };
1599
1600 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_inhibit_OUT_ARG_pointers[] =
1601 {
1602   &_org_freedesktop_udisks_method_info_inhibit_OUT_ARG_cookie,
1603   NULL
1604 };
1605
1606 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_inhibit_annotation_info_0 =
1607 {
1608   -1,
1609   (gchar *) "org.freedesktop.DBus.GLib.Async",
1610   (gchar *) "",
1611   NULL
1612 };
1613
1614 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_inhibit_annotation_info_pointers[] =
1615 {
1616   &_org_freedesktop_udisks_method_inhibit_annotation_info_0,
1617   NULL
1618 };
1619
1620 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_inhibit =
1621 {
1622   {
1623     -1,
1624     (gchar *) "Inhibit",
1625     NULL,
1626     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_inhibit_OUT_ARG_pointers,
1627     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_inhibit_annotation_info_pointers
1628   },
1629   "handle-inhibit",
1630   FALSE
1631 };
1632
1633 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_method_info_uninhibit_IN_ARG_cookie =
1634 {
1635   {
1636     -1,
1637     (gchar *) "cookie",
1638     (gchar *) "s",
1639     NULL
1640   },
1641   FALSE
1642 };
1643
1644 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_method_info_uninhibit_IN_ARG_pointers[] =
1645 {
1646   &_org_freedesktop_udisks_method_info_uninhibit_IN_ARG_cookie,
1647   NULL
1648 };
1649
1650 static const GDBusAnnotationInfo _org_freedesktop_udisks_method_uninhibit_annotation_info_0 =
1651 {
1652   -1,
1653   (gchar *) "org.freedesktop.DBus.GLib.Async",
1654   (gchar *) "",
1655   NULL
1656 };
1657
1658 static const GDBusAnnotationInfo * const _org_freedesktop_udisks_method_uninhibit_annotation_info_pointers[] =
1659 {
1660   &_org_freedesktop_udisks_method_uninhibit_annotation_info_0,
1661   NULL
1662 };
1663
1664 static const _ExtendedGDBusMethodInfo _org_freedesktop_udisks_method_info_uninhibit =
1665 {
1666   {
1667     -1,
1668     (gchar *) "Uninhibit",
1669     (GDBusArgInfo **) &_org_freedesktop_udisks_method_info_uninhibit_IN_ARG_pointers,
1670     NULL,
1671     (GDBusAnnotationInfo **) &_org_freedesktop_udisks_method_uninhibit_annotation_info_pointers
1672   },
1673   "handle-uninhibit",
1674   FALSE
1675 };
1676
1677 static const _ExtendedGDBusMethodInfo * const _org_freedesktop_udisks_method_info_pointers[] =
1678 {
1679   &_org_freedesktop_udisks_method_info_enumerate_adapters,
1680   &_org_freedesktop_udisks_method_info_enumerate_expanders,
1681   &_org_freedesktop_udisks_method_info_enumerate_ports,
1682   &_org_freedesktop_udisks_method_info_enumerate_devices,
1683   &_org_freedesktop_udisks_method_info_enumerate_device_files,
1684   &_org_freedesktop_udisks_method_info_find_device_by_device_file,
1685   &_org_freedesktop_udisks_method_info_find_device_by_major_minor,
1686   &_org_freedesktop_udisks_method_info_drive_inhibit_all_polling,
1687   &_org_freedesktop_udisks_method_info_drive_uninhibit_all_polling,
1688   &_org_freedesktop_udisks_method_info_drive_set_all_spindown_timeouts,
1689   &_org_freedesktop_udisks_method_info_drive_unset_all_spindown_timeouts,
1690   &_org_freedesktop_udisks_method_info_linux_lvm2_vgstart,
1691   &_org_freedesktop_udisks_method_info_linux_lvm2_vgstop,
1692   &_org_freedesktop_udisks_method_info_linux_lvm2_vgset_name,
1693   &_org_freedesktop_udisks_method_info_linux_lvm2_vgadd_pv,
1694   &_org_freedesktop_udisks_method_info_linux_lvm2_vgremove_pv,
1695   &_org_freedesktop_udisks_method_info_linux_lvm2_lvset_name,
1696   &_org_freedesktop_udisks_method_info_linux_lvm2_lvstart,
1697   &_org_freedesktop_udisks_method_info_linux_lvm2_lvremove,
1698   &_org_freedesktop_udisks_method_info_linux_lvm2_lvcreate,
1699   &_org_freedesktop_udisks_method_info_linux_md_start,
1700   &_org_freedesktop_udisks_method_info_linux_md_create,
1701   &_org_freedesktop_udisks_method_info_inhibit,
1702   &_org_freedesktop_udisks_method_info_uninhibit,
1703   NULL
1704 };
1705
1706 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_device_added_ARG_device =
1707 {
1708   {
1709     -1,
1710     (gchar *) "device",
1711     (gchar *) "o",
1712     NULL
1713   },
1714   FALSE
1715 };
1716
1717 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_signal_info_device_added_ARG_pointers[] =
1718 {
1719   &_org_freedesktop_udisks_signal_info_device_added_ARG_device,
1720   NULL
1721 };
1722
1723 static const _ExtendedGDBusSignalInfo _org_freedesktop_udisks_signal_info_device_added =
1724 {
1725   {
1726     -1,
1727     (gchar *) "DeviceAdded",
1728     (GDBusArgInfo **) &_org_freedesktop_udisks_signal_info_device_added_ARG_pointers,
1729     NULL
1730   },
1731   "device-added"
1732 };
1733
1734 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_device_removed_ARG_device =
1735 {
1736   {
1737     -1,
1738     (gchar *) "device",
1739     (gchar *) "o",
1740     NULL
1741   },
1742   FALSE
1743 };
1744
1745 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_signal_info_device_removed_ARG_pointers[] =
1746 {
1747   &_org_freedesktop_udisks_signal_info_device_removed_ARG_device,
1748   NULL
1749 };
1750
1751 static const _ExtendedGDBusSignalInfo _org_freedesktop_udisks_signal_info_device_removed =
1752 {
1753   {
1754     -1,
1755     (gchar *) "DeviceRemoved",
1756     (GDBusArgInfo **) &_org_freedesktop_udisks_signal_info_device_removed_ARG_pointers,
1757     NULL
1758   },
1759   "device-removed"
1760 };
1761
1762 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_device_changed_ARG_device =
1763 {
1764   {
1765     -1,
1766     (gchar *) "device",
1767     (gchar *) "o",
1768     NULL
1769   },
1770   FALSE
1771 };
1772
1773 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_signal_info_device_changed_ARG_pointers[] =
1774 {
1775   &_org_freedesktop_udisks_signal_info_device_changed_ARG_device,
1776   NULL
1777 };
1778
1779 static const _ExtendedGDBusSignalInfo _org_freedesktop_udisks_signal_info_device_changed =
1780 {
1781   {
1782     -1,
1783     (gchar *) "DeviceChanged",
1784     (GDBusArgInfo **) &_org_freedesktop_udisks_signal_info_device_changed_ARG_pointers,
1785     NULL
1786   },
1787   "device-changed"
1788 };
1789
1790 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_device_job_changed_ARG_device =
1791 {
1792   {
1793     -1,
1794     (gchar *) "device",
1795     (gchar *) "o",
1796     NULL
1797   },
1798   FALSE
1799 };
1800
1801 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_in_progress =
1802 {
1803   {
1804     -1,
1805     (gchar *) "job_in_progress",
1806     (gchar *) "b",
1807     NULL
1808   },
1809   FALSE
1810 };
1811
1812 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_is_cancellable =
1813 {
1814   {
1815     -1,
1816     (gchar *) "job_is_cancellable",
1817     (gchar *) "b",
1818     NULL
1819   },
1820   FALSE
1821 };
1822
1823 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_id =
1824 {
1825   {
1826     -1,
1827     (gchar *) "job_id",
1828     (gchar *) "s",
1829     NULL
1830   },
1831   FALSE
1832 };
1833
1834 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_num_tasks =
1835 {
1836   {
1837     -1,
1838     (gchar *) "job_num_tasks",
1839     (gchar *) "i",
1840     NULL
1841   },
1842   FALSE
1843 };
1844
1845 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_cur_task =
1846 {
1847   {
1848     -1,
1849     (gchar *) "job_cur_task",
1850     (gchar *) "i",
1851     NULL
1852   },
1853   FALSE
1854 };
1855
1856 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_cur_task_id =
1857 {
1858   {
1859     -1,
1860     (gchar *) "job_cur_task_id",
1861     (gchar *) "s",
1862     NULL
1863   },
1864   FALSE
1865 };
1866
1867 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_cur_task_percentage =
1868 {
1869   {
1870     -1,
1871     (gchar *) "job_cur_task_percentage",
1872     (gchar *) "d",
1873     NULL
1874   },
1875   FALSE
1876 };
1877
1878 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_signal_info_device_job_changed_ARG_pointers[] =
1879 {
1880   &_org_freedesktop_udisks_signal_info_device_job_changed_ARG_device,
1881   &_org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_in_progress,
1882   &_org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_is_cancellable,
1883   &_org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_id,
1884   &_org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_num_tasks,
1885   &_org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_cur_task,
1886   &_org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_cur_task_id,
1887   &_org_freedesktop_udisks_signal_info_device_job_changed_ARG_job_cur_task_percentage,
1888   NULL
1889 };
1890
1891 static const _ExtendedGDBusSignalInfo _org_freedesktop_udisks_signal_info_device_job_changed =
1892 {
1893   {
1894     -1,
1895     (gchar *) "DeviceJobChanged",
1896     (GDBusArgInfo **) &_org_freedesktop_udisks_signal_info_device_job_changed_ARG_pointers,
1897     NULL
1898   },
1899   "device-job-changed"
1900 };
1901
1902 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_adapter_added_ARG_adapter =
1903 {
1904   {
1905     -1,
1906     (gchar *) "adapter",
1907     (gchar *) "o",
1908     NULL
1909   },
1910   FALSE
1911 };
1912
1913 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_signal_info_adapter_added_ARG_pointers[] =
1914 {
1915   &_org_freedesktop_udisks_signal_info_adapter_added_ARG_adapter,
1916   NULL
1917 };
1918
1919 static const _ExtendedGDBusSignalInfo _org_freedesktop_udisks_signal_info_adapter_added =
1920 {
1921   {
1922     -1,
1923     (gchar *) "AdapterAdded",
1924     (GDBusArgInfo **) &_org_freedesktop_udisks_signal_info_adapter_added_ARG_pointers,
1925     NULL
1926   },
1927   "adapter-added"
1928 };
1929
1930 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_adapter_removed_ARG_adapter =
1931 {
1932   {
1933     -1,
1934     (gchar *) "adapter",
1935     (gchar *) "o",
1936     NULL
1937   },
1938   FALSE
1939 };
1940
1941 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_signal_info_adapter_removed_ARG_pointers[] =
1942 {
1943   &_org_freedesktop_udisks_signal_info_adapter_removed_ARG_adapter,
1944   NULL
1945 };
1946
1947 static const _ExtendedGDBusSignalInfo _org_freedesktop_udisks_signal_info_adapter_removed =
1948 {
1949   {
1950     -1,
1951     (gchar *) "AdapterRemoved",
1952     (GDBusArgInfo **) &_org_freedesktop_udisks_signal_info_adapter_removed_ARG_pointers,
1953     NULL
1954   },
1955   "adapter-removed"
1956 };
1957
1958 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_adapter_changed_ARG_adapter =
1959 {
1960   {
1961     -1,
1962     (gchar *) "adapter",
1963     (gchar *) "o",
1964     NULL
1965   },
1966   FALSE
1967 };
1968
1969 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_signal_info_adapter_changed_ARG_pointers[] =
1970 {
1971   &_org_freedesktop_udisks_signal_info_adapter_changed_ARG_adapter,
1972   NULL
1973 };
1974
1975 static const _ExtendedGDBusSignalInfo _org_freedesktop_udisks_signal_info_adapter_changed =
1976 {
1977   {
1978     -1,
1979     (gchar *) "AdapterChanged",
1980     (GDBusArgInfo **) &_org_freedesktop_udisks_signal_info_adapter_changed_ARG_pointers,
1981     NULL
1982   },
1983   "adapter-changed"
1984 };
1985
1986 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_expander_added_ARG_expander =
1987 {
1988   {
1989     -1,
1990     (gchar *) "expander",
1991     (gchar *) "o",
1992     NULL
1993   },
1994   FALSE
1995 };
1996
1997 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_signal_info_expander_added_ARG_pointers[] =
1998 {
1999   &_org_freedesktop_udisks_signal_info_expander_added_ARG_expander,
2000   NULL
2001 };
2002
2003 static const _ExtendedGDBusSignalInfo _org_freedesktop_udisks_signal_info_expander_added =
2004 {
2005   {
2006     -1,
2007     (gchar *) "ExpanderAdded",
2008     (GDBusArgInfo **) &_org_freedesktop_udisks_signal_info_expander_added_ARG_pointers,
2009     NULL
2010   },
2011   "expander-added"
2012 };
2013
2014 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_expander_removed_ARG_expander =
2015 {
2016   {
2017     -1,
2018     (gchar *) "expander",
2019     (gchar *) "o",
2020     NULL
2021   },
2022   FALSE
2023 };
2024
2025 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_signal_info_expander_removed_ARG_pointers[] =
2026 {
2027   &_org_freedesktop_udisks_signal_info_expander_removed_ARG_expander,
2028   NULL
2029 };
2030
2031 static const _ExtendedGDBusSignalInfo _org_freedesktop_udisks_signal_info_expander_removed =
2032 {
2033   {
2034     -1,
2035     (gchar *) "ExpanderRemoved",
2036     (GDBusArgInfo **) &_org_freedesktop_udisks_signal_info_expander_removed_ARG_pointers,
2037     NULL
2038   },
2039   "expander-removed"
2040 };
2041
2042 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_expander_changed_ARG_expander =
2043 {
2044   {
2045     -1,
2046     (gchar *) "expander",
2047     (gchar *) "o",
2048     NULL
2049   },
2050   FALSE
2051 };
2052
2053 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_signal_info_expander_changed_ARG_pointers[] =
2054 {
2055   &_org_freedesktop_udisks_signal_info_expander_changed_ARG_expander,
2056   NULL
2057 };
2058
2059 static const _ExtendedGDBusSignalInfo _org_freedesktop_udisks_signal_info_expander_changed =
2060 {
2061   {
2062     -1,
2063     (gchar *) "ExpanderChanged",
2064     (GDBusArgInfo **) &_org_freedesktop_udisks_signal_info_expander_changed_ARG_pointers,
2065     NULL
2066   },
2067   "expander-changed"
2068 };
2069
2070 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_port_added_ARG_port =
2071 {
2072   {
2073     -1,
2074     (gchar *) "port",
2075     (gchar *) "o",
2076     NULL
2077   },
2078   FALSE
2079 };
2080
2081 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_signal_info_port_added_ARG_pointers[] =
2082 {
2083   &_org_freedesktop_udisks_signal_info_port_added_ARG_port,
2084   NULL
2085 };
2086
2087 static const _ExtendedGDBusSignalInfo _org_freedesktop_udisks_signal_info_port_added =
2088 {
2089   {
2090     -1,
2091     (gchar *) "PortAdded",
2092     (GDBusArgInfo **) &_org_freedesktop_udisks_signal_info_port_added_ARG_pointers,
2093     NULL
2094   },
2095   "port-added"
2096 };
2097
2098 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_port_removed_ARG_port =
2099 {
2100   {
2101     -1,
2102     (gchar *) "port",
2103     (gchar *) "o",
2104     NULL
2105   },
2106   FALSE
2107 };
2108
2109 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_signal_info_port_removed_ARG_pointers[] =
2110 {
2111   &_org_freedesktop_udisks_signal_info_port_removed_ARG_port,
2112   NULL
2113 };
2114
2115 static const _ExtendedGDBusSignalInfo _org_freedesktop_udisks_signal_info_port_removed =
2116 {
2117   {
2118     -1,
2119     (gchar *) "PortRemoved",
2120     (GDBusArgInfo **) &_org_freedesktop_udisks_signal_info_port_removed_ARG_pointers,
2121     NULL
2122   },
2123   "port-removed"
2124 };
2125
2126 static const _ExtendedGDBusArgInfo _org_freedesktop_udisks_signal_info_port_changed_ARG_port =
2127 {
2128   {
2129     -1,
2130     (gchar *) "port",
2131     (gchar *) "o",
2132     NULL
2133   },
2134   FALSE
2135 };
2136
2137 static const _ExtendedGDBusArgInfo * const _org_freedesktop_udisks_signal_info_port_changed_ARG_pointers[] =
2138 {
2139   &_org_freedesktop_udisks_signal_info_port_changed_ARG_port,
2140   NULL
2141 };
2142
2143 static const _ExtendedGDBusSignalInfo _org_freedesktop_udisks_signal_info_port_changed =
2144 {
2145   {
2146     -1,
2147     (gchar *) "PortChanged",
2148     (GDBusArgInfo **) &_org_freedesktop_udisks_signal_info_port_changed_ARG_pointers,
2149     NULL
2150   },
2151   "port-changed"
2152 };
2153
2154 static const _ExtendedGDBusSignalInfo * const _org_freedesktop_udisks_signal_info_pointers[] =
2155 {
2156   &_org_freedesktop_udisks_signal_info_device_added,
2157   &_org_freedesktop_udisks_signal_info_device_removed,
2158   &_org_freedesktop_udisks_signal_info_device_changed,
2159   &_org_freedesktop_udisks_signal_info_device_job_changed,
2160   &_org_freedesktop_udisks_signal_info_adapter_added,
2161   &_org_freedesktop_udisks_signal_info_adapter_removed,
2162   &_org_freedesktop_udisks_signal_info_adapter_changed,
2163   &_org_freedesktop_udisks_signal_info_expander_added,
2164   &_org_freedesktop_udisks_signal_info_expander_removed,
2165   &_org_freedesktop_udisks_signal_info_expander_changed,
2166   &_org_freedesktop_udisks_signal_info_port_added,
2167   &_org_freedesktop_udisks_signal_info_port_removed,
2168   &_org_freedesktop_udisks_signal_info_port_changed,
2169   NULL
2170 };
2171
2172 static const _ExtendedGDBusPropertyInfo _org_freedesktop_udisks_property_info_daemon_version =
2173 {
2174   {
2175     -1,
2176     (gchar *) "DaemonVersion",
2177     (gchar *) "s",
2178     G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
2179     NULL
2180   },
2181   "daemon-version",
2182   FALSE
2183 };
2184
2185 static const _ExtendedGDBusPropertyInfo _org_freedesktop_udisks_property_info_daemon_is_inhibited =
2186 {
2187   {
2188     -1,
2189     (gchar *) "DaemonIsInhibited",
2190     (gchar *) "b",
2191     G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
2192     NULL
2193   },
2194   "daemon-is-inhibited",
2195   FALSE
2196 };
2197
2198 static const _ExtendedGDBusPropertyInfo _org_freedesktop_udisks_property_info_supports_luks_devices =
2199 {
2200   {
2201     -1,
2202     (gchar *) "SupportsLuksDevices",
2203     (gchar *) "b",
2204     G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
2205     NULL
2206   },
2207   "supports-luks-devices",
2208   FALSE
2209 };
2210
2211 static const _ExtendedGDBusPropertyInfo _org_freedesktop_udisks_property_info_known_filesystems =
2212 {
2213   {
2214     -1,
2215     (gchar *) "KnownFilesystems",
2216     (gchar *) "a(ssbbbubbbbbbbb)",
2217     G_DBUS_PROPERTY_INFO_FLAGS_READABLE,
2218     NULL
2219   },
2220   "known-filesystems",
2221   FALSE
2222 };
2223
2224 static const _ExtendedGDBusPropertyInfo * const _org_freedesktop_udisks_property_info_pointers[] =
2225 {
2226   &_org_freedesktop_udisks_property_info_daemon_version,
2227   &_org_freedesktop_udisks_property_info_daemon_is_inhibited,
2228   &_org_freedesktop_udisks_property_info_supports_luks_devices,
2229   &_org_freedesktop_udisks_property_info_known_filesystems,
2230   NULL
2231 };
2232
2233 static const _ExtendedGDBusInterfaceInfo _org_freedesktop_udisks_interface_info =
2234 {
2235   {
2236     -1,
2237     (gchar *) "org.freedesktop.UDisks",
2238     (GDBusMethodInfo **) &_org_freedesktop_udisks_method_info_pointers,
2239     (GDBusSignalInfo **) &_org_freedesktop_udisks_signal_info_pointers,
2240     (GDBusPropertyInfo **) &_org_freedesktop_udisks_property_info_pointers,
2241     NULL
2242   },
2243   "org-freedesktop-udisks",
2244 };
2245
2246
2247 /**
2248  * org_freedesktop_udisks_interface_info:
2249  *
2250  * Gets a machine-readable description of the <link linkend="gdbus-interface-org-freedesktop-UDisks.top_of_page">org.freedesktop.UDisks</link> D-Bus interface.
2251  *
2252  * Returns: (transfer none): A #GDBusInterfaceInfo. Do not free.
2253  */
2254 GDBusInterfaceInfo *
2255 org_freedesktop_udisks_interface_info (void)
2256 {
2257   return (GDBusInterfaceInfo *) &_org_freedesktop_udisks_interface_info.parent_struct;
2258 }
2259
2260 /**
2261  * org_freedesktop_udisks_override_properties:
2262  * @klass: The class structure for a #GObject<!-- -->-derived class.
2263  * @property_id_begin: The property id to assign to the first overridden property.
2264  *
2265  * Overrides all #GObject properties in the #OrgFreedesktopUDisks interface for a concrete class.
2266  * The properties are overridden in the order they are defined.
2267  *
2268  * Returns: The last property id.
2269  */
2270 guint
2271 org_freedesktop_udisks_override_properties (GObjectClass *klass, guint property_id_begin)
2272 {
2273   g_object_class_override_property (klass, property_id_begin++, "daemon-version");
2274   g_object_class_override_property (klass, property_id_begin++, "daemon-is-inhibited");
2275   g_object_class_override_property (klass, property_id_begin++, "supports-luks-devices");
2276   g_object_class_override_property (klass, property_id_begin++, "known-filesystems");
2277   return property_id_begin - 1;
2278 }
2279
2280
2281
2282 /**
2283  * OrgFreedesktopUDisks:
2284  *
2285  * Abstract interface type for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks.top_of_page">org.freedesktop.UDisks</link>.
2286  */
2287
2288 /**
2289  * OrgFreedesktopUDisksIface:
2290  * @parent_iface: The parent interface.
2291  * @handle_drive_inhibit_all_polling: Handler for the #OrgFreedesktopUDisks::handle-drive-inhibit-all-polling signal.
2292  * @handle_drive_set_all_spindown_timeouts: Handler for the #OrgFreedesktopUDisks::handle-drive-set-all-spindown-timeouts signal.
2293  * @handle_drive_uninhibit_all_polling: Handler for the #OrgFreedesktopUDisks::handle-drive-uninhibit-all-polling signal.
2294  * @handle_drive_unset_all_spindown_timeouts: Handler for the #OrgFreedesktopUDisks::handle-drive-unset-all-spindown-timeouts signal.
2295  * @handle_enumerate_adapters: Handler for the #OrgFreedesktopUDisks::handle-enumerate-adapters signal.
2296  * @handle_enumerate_device_files: Handler for the #OrgFreedesktopUDisks::handle-enumerate-device-files signal.
2297  * @handle_enumerate_devices: Handler for the #OrgFreedesktopUDisks::handle-enumerate-devices signal.
2298  * @handle_enumerate_expanders: Handler for the #OrgFreedesktopUDisks::handle-enumerate-expanders signal.
2299  * @handle_enumerate_ports: Handler for the #OrgFreedesktopUDisks::handle-enumerate-ports signal.
2300  * @handle_find_device_by_device_file: Handler for the #OrgFreedesktopUDisks::handle-find-device-by-device-file signal.
2301  * @handle_find_device_by_major_minor: Handler for the #OrgFreedesktopUDisks::handle-find-device-by-major-minor signal.
2302  * @handle_inhibit: Handler for the #OrgFreedesktopUDisks::handle-inhibit signal.
2303  * @handle_linux_lvm2_lvcreate: Handler for the #OrgFreedesktopUDisks::handle-linux-lvm2-lvcreate signal.
2304  * @handle_linux_lvm2_lvremove: Handler for the #OrgFreedesktopUDisks::handle-linux-lvm2-lvremove signal.
2305  * @handle_linux_lvm2_lvset_name: Handler for the #OrgFreedesktopUDisks::handle-linux-lvm2-lvset-name signal.
2306  * @handle_linux_lvm2_lvstart: Handler for the #OrgFreedesktopUDisks::handle-linux-lvm2-lvstart signal.
2307  * @handle_linux_lvm2_vgadd_pv: Handler for the #OrgFreedesktopUDisks::handle-linux-lvm2-vgadd-pv signal.
2308  * @handle_linux_lvm2_vgremove_pv: Handler for the #OrgFreedesktopUDisks::handle-linux-lvm2-vgremove-pv signal.
2309  * @handle_linux_lvm2_vgset_name: Handler for the #OrgFreedesktopUDisks::handle-linux-lvm2-vgset-name signal.
2310  * @handle_linux_lvm2_vgstart: Handler for the #OrgFreedesktopUDisks::handle-linux-lvm2-vgstart signal.
2311  * @handle_linux_lvm2_vgstop: Handler for the #OrgFreedesktopUDisks::handle-linux-lvm2-vgstop signal.
2312  * @handle_linux_md_create: Handler for the #OrgFreedesktopUDisks::handle-linux-md-create signal.
2313  * @handle_linux_md_start: Handler for the #OrgFreedesktopUDisks::handle-linux-md-start signal.
2314  * @handle_uninhibit: Handler for the #OrgFreedesktopUDisks::handle-uninhibit signal.
2315  * @get_daemon_is_inhibited: Getter for the #OrgFreedesktopUDisks:daemon-is-inhibited property.
2316  * @get_daemon_version: Getter for the #OrgFreedesktopUDisks:daemon-version property.
2317  * @get_known_filesystems: Getter for the #OrgFreedesktopUDisks:known-filesystems property.
2318  * @get_supports_luks_devices: Getter for the #OrgFreedesktopUDisks:supports-luks-devices property.
2319  * @adapter_added: Handler for the #OrgFreedesktopUDisks::adapter-added signal.
2320  * @adapter_changed: Handler for the #OrgFreedesktopUDisks::adapter-changed signal.
2321  * @adapter_removed: Handler for the #OrgFreedesktopUDisks::adapter-removed signal.
2322  * @device_added: Handler for the #OrgFreedesktopUDisks::device-added signal.
2323  * @device_changed: Handler for the #OrgFreedesktopUDisks::device-changed signal.
2324  * @device_job_changed: Handler for the #OrgFreedesktopUDisks::device-job-changed signal.
2325  * @device_removed: Handler for the #OrgFreedesktopUDisks::device-removed signal.
2326  * @expander_added: Handler for the #OrgFreedesktopUDisks::expander-added signal.
2327  * @expander_changed: Handler for the #OrgFreedesktopUDisks::expander-changed signal.
2328  * @expander_removed: Handler for the #OrgFreedesktopUDisks::expander-removed signal.
2329  * @port_added: Handler for the #OrgFreedesktopUDisks::port-added signal.
2330  * @port_changed: Handler for the #OrgFreedesktopUDisks::port-changed signal.
2331  * @port_removed: Handler for the #OrgFreedesktopUDisks::port-removed signal.
2332  *
2333  * Virtual table for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks.top_of_page">org.freedesktop.UDisks</link>.
2334  */
2335
2336 typedef OrgFreedesktopUDisksIface OrgFreedesktopUDisksInterface;
2337 G_DEFINE_INTERFACE (OrgFreedesktopUDisks, org_freedesktop_udisks, G_TYPE_OBJECT);
2338
2339 static void
2340 org_freedesktop_udisks_default_init (OrgFreedesktopUDisksIface *iface)
2341 {
2342   /* GObject signals for incoming D-Bus method calls: */
2343   /**
2344    * OrgFreedesktopUDisks::handle-enumerate-adapters:
2345    * @object: A #OrgFreedesktopUDisks.
2346    * @invocation: A #GDBusMethodInvocation.
2347    *
2348    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateAdapters">EnumerateAdapters()</link> D-Bus method.
2349    *
2350    * 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 org_freedesktop_udisks_complete_enumerate_adapters() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2351    *
2352    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2353    */
2354   g_signal_new ("handle-enumerate-adapters",
2355     G_TYPE_FROM_INTERFACE (iface),
2356     G_SIGNAL_RUN_LAST,
2357     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_enumerate_adapters),
2358     g_signal_accumulator_true_handled,
2359     NULL,
2360     g_cclosure_marshal_generic,
2361     G_TYPE_BOOLEAN,
2362     1,
2363     G_TYPE_DBUS_METHOD_INVOCATION);
2364
2365   /**
2366    * OrgFreedesktopUDisks::handle-enumerate-expanders:
2367    * @object: A #OrgFreedesktopUDisks.
2368    * @invocation: A #GDBusMethodInvocation.
2369    *
2370    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateExpanders">EnumerateExpanders()</link> D-Bus method.
2371    *
2372    * 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 org_freedesktop_udisks_complete_enumerate_expanders() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2373    *
2374    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2375    */
2376   g_signal_new ("handle-enumerate-expanders",
2377     G_TYPE_FROM_INTERFACE (iface),
2378     G_SIGNAL_RUN_LAST,
2379     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_enumerate_expanders),
2380     g_signal_accumulator_true_handled,
2381     NULL,
2382     g_cclosure_marshal_generic,
2383     G_TYPE_BOOLEAN,
2384     1,
2385     G_TYPE_DBUS_METHOD_INVOCATION);
2386
2387   /**
2388    * OrgFreedesktopUDisks::handle-enumerate-ports:
2389    * @object: A #OrgFreedesktopUDisks.
2390    * @invocation: A #GDBusMethodInvocation.
2391    *
2392    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumeratePorts">EnumeratePorts()</link> D-Bus method.
2393    *
2394    * 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 org_freedesktop_udisks_complete_enumerate_ports() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2395    *
2396    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2397    */
2398   g_signal_new ("handle-enumerate-ports",
2399     G_TYPE_FROM_INTERFACE (iface),
2400     G_SIGNAL_RUN_LAST,
2401     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_enumerate_ports),
2402     g_signal_accumulator_true_handled,
2403     NULL,
2404     g_cclosure_marshal_generic,
2405     G_TYPE_BOOLEAN,
2406     1,
2407     G_TYPE_DBUS_METHOD_INVOCATION);
2408
2409   /**
2410    * OrgFreedesktopUDisks::handle-enumerate-devices:
2411    * @object: A #OrgFreedesktopUDisks.
2412    * @invocation: A #GDBusMethodInvocation.
2413    *
2414    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateDevices">EnumerateDevices()</link> D-Bus method.
2415    *
2416    * 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 org_freedesktop_udisks_complete_enumerate_devices() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2417    *
2418    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2419    */
2420   g_signal_new ("handle-enumerate-devices",
2421     G_TYPE_FROM_INTERFACE (iface),
2422     G_SIGNAL_RUN_LAST,
2423     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_enumerate_devices),
2424     g_signal_accumulator_true_handled,
2425     NULL,
2426     g_cclosure_marshal_generic,
2427     G_TYPE_BOOLEAN,
2428     1,
2429     G_TYPE_DBUS_METHOD_INVOCATION);
2430
2431   /**
2432    * OrgFreedesktopUDisks::handle-enumerate-device-files:
2433    * @object: A #OrgFreedesktopUDisks.
2434    * @invocation: A #GDBusMethodInvocation.
2435    *
2436    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateDeviceFiles">EnumerateDeviceFiles()</link> D-Bus method.
2437    *
2438    * 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 org_freedesktop_udisks_complete_enumerate_device_files() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2439    *
2440    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2441    */
2442   g_signal_new ("handle-enumerate-device-files",
2443     G_TYPE_FROM_INTERFACE (iface),
2444     G_SIGNAL_RUN_LAST,
2445     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_enumerate_device_files),
2446     g_signal_accumulator_true_handled,
2447     NULL,
2448     g_cclosure_marshal_generic,
2449     G_TYPE_BOOLEAN,
2450     1,
2451     G_TYPE_DBUS_METHOD_INVOCATION);
2452
2453   /**
2454    * OrgFreedesktopUDisks::handle-find-device-by-device-file:
2455    * @object: A #OrgFreedesktopUDisks.
2456    * @invocation: A #GDBusMethodInvocation.
2457    * @arg_device_file: Argument passed by remote caller.
2458    *
2459    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.FindDeviceByDeviceFile">FindDeviceByDeviceFile()</link> D-Bus method.
2460    *
2461    * 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 org_freedesktop_udisks_complete_find_device_by_device_file() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2462    *
2463    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2464    */
2465   g_signal_new ("handle-find-device-by-device-file",
2466     G_TYPE_FROM_INTERFACE (iface),
2467     G_SIGNAL_RUN_LAST,
2468     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_find_device_by_device_file),
2469     g_signal_accumulator_true_handled,
2470     NULL,
2471     g_cclosure_marshal_generic,
2472     G_TYPE_BOOLEAN,
2473     2,
2474     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);
2475
2476   /**
2477    * OrgFreedesktopUDisks::handle-find-device-by-major-minor:
2478    * @object: A #OrgFreedesktopUDisks.
2479    * @invocation: A #GDBusMethodInvocation.
2480    * @arg_device_major: Argument passed by remote caller.
2481    * @arg_device_minor: Argument passed by remote caller.
2482    *
2483    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.FindDeviceByMajorMinor">FindDeviceByMajorMinor()</link> D-Bus method.
2484    *
2485    * 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 org_freedesktop_udisks_complete_find_device_by_major_minor() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2486    *
2487    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2488    */
2489   g_signal_new ("handle-find-device-by-major-minor",
2490     G_TYPE_FROM_INTERFACE (iface),
2491     G_SIGNAL_RUN_LAST,
2492     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_find_device_by_major_minor),
2493     g_signal_accumulator_true_handled,
2494     NULL,
2495     g_cclosure_marshal_generic,
2496     G_TYPE_BOOLEAN,
2497     3,
2498     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_INT64, G_TYPE_INT64);
2499
2500   /**
2501    * OrgFreedesktopUDisks::handle-drive-inhibit-all-polling:
2502    * @object: A #OrgFreedesktopUDisks.
2503    * @invocation: A #GDBusMethodInvocation.
2504    * @arg_options: Argument passed by remote caller.
2505    *
2506    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveInhibitAllPolling">DriveInhibitAllPolling()</link> D-Bus method.
2507    *
2508    * 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 org_freedesktop_udisks_complete_drive_inhibit_all_polling() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2509    *
2510    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2511    */
2512   g_signal_new ("handle-drive-inhibit-all-polling",
2513     G_TYPE_FROM_INTERFACE (iface),
2514     G_SIGNAL_RUN_LAST,
2515     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_drive_inhibit_all_polling),
2516     g_signal_accumulator_true_handled,
2517     NULL,
2518     g_cclosure_marshal_generic,
2519     G_TYPE_BOOLEAN,
2520     2,
2521     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRV);
2522
2523   /**
2524    * OrgFreedesktopUDisks::handle-drive-uninhibit-all-polling:
2525    * @object: A #OrgFreedesktopUDisks.
2526    * @invocation: A #GDBusMethodInvocation.
2527    * @arg_cookie: Argument passed by remote caller.
2528    *
2529    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveUninhibitAllPolling">DriveUninhibitAllPolling()</link> D-Bus method.
2530    *
2531    * 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 org_freedesktop_udisks_complete_drive_uninhibit_all_polling() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2532    *
2533    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2534    */
2535   g_signal_new ("handle-drive-uninhibit-all-polling",
2536     G_TYPE_FROM_INTERFACE (iface),
2537     G_SIGNAL_RUN_LAST,
2538     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_drive_uninhibit_all_polling),
2539     g_signal_accumulator_true_handled,
2540     NULL,
2541     g_cclosure_marshal_generic,
2542     G_TYPE_BOOLEAN,
2543     2,
2544     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);
2545
2546   /**
2547    * OrgFreedesktopUDisks::handle-drive-set-all-spindown-timeouts:
2548    * @object: A #OrgFreedesktopUDisks.
2549    * @invocation: A #GDBusMethodInvocation.
2550    * @arg_timeout_seconds: Argument passed by remote caller.
2551    * @arg_options: Argument passed by remote caller.
2552    *
2553    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveSetAllSpindownTimeouts">DriveSetAllSpindownTimeouts()</link> D-Bus method.
2554    *
2555    * 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 org_freedesktop_udisks_complete_drive_set_all_spindown_timeouts() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2556    *
2557    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2558    */
2559   g_signal_new ("handle-drive-set-all-spindown-timeouts",
2560     G_TYPE_FROM_INTERFACE (iface),
2561     G_SIGNAL_RUN_LAST,
2562     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_drive_set_all_spindown_timeouts),
2563     g_signal_accumulator_true_handled,
2564     NULL,
2565     g_cclosure_marshal_generic,
2566     G_TYPE_BOOLEAN,
2567     3,
2568     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_INT, G_TYPE_STRV);
2569
2570   /**
2571    * OrgFreedesktopUDisks::handle-drive-unset-all-spindown-timeouts:
2572    * @object: A #OrgFreedesktopUDisks.
2573    * @invocation: A #GDBusMethodInvocation.
2574    * @arg_cookie: Argument passed by remote caller.
2575    *
2576    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveUnsetAllSpindownTimeouts">DriveUnsetAllSpindownTimeouts()</link> D-Bus method.
2577    *
2578    * 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 org_freedesktop_udisks_complete_drive_unset_all_spindown_timeouts() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2579    *
2580    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2581    */
2582   g_signal_new ("handle-drive-unset-all-spindown-timeouts",
2583     G_TYPE_FROM_INTERFACE (iface),
2584     G_SIGNAL_RUN_LAST,
2585     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_drive_unset_all_spindown_timeouts),
2586     g_signal_accumulator_true_handled,
2587     NULL,
2588     g_cclosure_marshal_generic,
2589     G_TYPE_BOOLEAN,
2590     2,
2591     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);
2592
2593   /**
2594    * OrgFreedesktopUDisks::handle-linux-lvm2-vgstart:
2595    * @object: A #OrgFreedesktopUDisks.
2596    * @invocation: A #GDBusMethodInvocation.
2597    * @arg_uuid: Argument passed by remote caller.
2598    * @arg_options: Argument passed by remote caller.
2599    *
2600    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGStart">LinuxLvm2VGStart()</link> D-Bus method.
2601    *
2602    * 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 org_freedesktop_udisks_complete_linux_lvm2_vgstart() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2603    *
2604    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2605    */
2606   g_signal_new ("handle-linux-lvm2-vgstart",
2607     G_TYPE_FROM_INTERFACE (iface),
2608     G_SIGNAL_RUN_LAST,
2609     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_linux_lvm2_vgstart),
2610     g_signal_accumulator_true_handled,
2611     NULL,
2612     g_cclosure_marshal_generic,
2613     G_TYPE_BOOLEAN,
2614     3,
2615     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRV);
2616
2617   /**
2618    * OrgFreedesktopUDisks::handle-linux-lvm2-vgstop:
2619    * @object: A #OrgFreedesktopUDisks.
2620    * @invocation: A #GDBusMethodInvocation.
2621    * @arg_uuid: Argument passed by remote caller.
2622    * @arg_options: Argument passed by remote caller.
2623    *
2624    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGStop">LinuxLvm2VGStop()</link> D-Bus method.
2625    *
2626    * 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 org_freedesktop_udisks_complete_linux_lvm2_vgstop() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2627    *
2628    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2629    */
2630   g_signal_new ("handle-linux-lvm2-vgstop",
2631     G_TYPE_FROM_INTERFACE (iface),
2632     G_SIGNAL_RUN_LAST,
2633     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_linux_lvm2_vgstop),
2634     g_signal_accumulator_true_handled,
2635     NULL,
2636     g_cclosure_marshal_generic,
2637     G_TYPE_BOOLEAN,
2638     3,
2639     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRV);
2640
2641   /**
2642    * OrgFreedesktopUDisks::handle-linux-lvm2-vgset-name:
2643    * @object: A #OrgFreedesktopUDisks.
2644    * @invocation: A #GDBusMethodInvocation.
2645    * @arg_uuid: Argument passed by remote caller.
2646    * @arg_name: Argument passed by remote caller.
2647    *
2648    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGSetName">LinuxLvm2VGSetName()</link> D-Bus method.
2649    *
2650    * 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 org_freedesktop_udisks_complete_linux_lvm2_vgset_name() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2651    *
2652    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2653    */
2654   g_signal_new ("handle-linux-lvm2-vgset-name",
2655     G_TYPE_FROM_INTERFACE (iface),
2656     G_SIGNAL_RUN_LAST,
2657     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_linux_lvm2_vgset_name),
2658     g_signal_accumulator_true_handled,
2659     NULL,
2660     g_cclosure_marshal_generic,
2661     G_TYPE_BOOLEAN,
2662     3,
2663     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING);
2664
2665   /**
2666    * OrgFreedesktopUDisks::handle-linux-lvm2-vgadd-pv:
2667    * @object: A #OrgFreedesktopUDisks.
2668    * @invocation: A #GDBusMethodInvocation.
2669    * @arg_uuid: Argument passed by remote caller.
2670    * @arg_physical_volume: Argument passed by remote caller.
2671    * @arg_options: Argument passed by remote caller.
2672    *
2673    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGAddPV">LinuxLvm2VGAddPV()</link> D-Bus method.
2674    *
2675    * 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 org_freedesktop_udisks_complete_linux_lvm2_vgadd_pv() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2676    *
2677    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2678    */
2679   g_signal_new ("handle-linux-lvm2-vgadd-pv",
2680     G_TYPE_FROM_INTERFACE (iface),
2681     G_SIGNAL_RUN_LAST,
2682     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_linux_lvm2_vgadd_pv),
2683     g_signal_accumulator_true_handled,
2684     NULL,
2685     g_cclosure_marshal_generic,
2686     G_TYPE_BOOLEAN,
2687     4,
2688     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRV);
2689
2690   /**
2691    * OrgFreedesktopUDisks::handle-linux-lvm2-vgremove-pv:
2692    * @object: A #OrgFreedesktopUDisks.
2693    * @invocation: A #GDBusMethodInvocation.
2694    * @arg_vg_uuid: Argument passed by remote caller.
2695    * @arg_pv_uuid: Argument passed by remote caller.
2696    * @arg_options: Argument passed by remote caller.
2697    *
2698    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGRemovePV">LinuxLvm2VGRemovePV()</link> D-Bus method.
2699    *
2700    * 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 org_freedesktop_udisks_complete_linux_lvm2_vgremove_pv() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2701    *
2702    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2703    */
2704   g_signal_new ("handle-linux-lvm2-vgremove-pv",
2705     G_TYPE_FROM_INTERFACE (iface),
2706     G_SIGNAL_RUN_LAST,
2707     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_linux_lvm2_vgremove_pv),
2708     g_signal_accumulator_true_handled,
2709     NULL,
2710     g_cclosure_marshal_generic,
2711     G_TYPE_BOOLEAN,
2712     4,
2713     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRV);
2714
2715   /**
2716    * OrgFreedesktopUDisks::handle-linux-lvm2-lvset-name:
2717    * @object: A #OrgFreedesktopUDisks.
2718    * @invocation: A #GDBusMethodInvocation.
2719    * @arg_group_uuid: Argument passed by remote caller.
2720    * @arg_uuid: Argument passed by remote caller.
2721    * @arg_name: Argument passed by remote caller.
2722    *
2723    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVSetName">LinuxLvm2LVSetName()</link> D-Bus method.
2724    *
2725    * 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 org_freedesktop_udisks_complete_linux_lvm2_lvset_name() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2726    *
2727    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2728    */
2729   g_signal_new ("handle-linux-lvm2-lvset-name",
2730     G_TYPE_FROM_INTERFACE (iface),
2731     G_SIGNAL_RUN_LAST,
2732     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_linux_lvm2_lvset_name),
2733     g_signal_accumulator_true_handled,
2734     NULL,
2735     g_cclosure_marshal_generic,
2736     G_TYPE_BOOLEAN,
2737     4,
2738     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRING);
2739
2740   /**
2741    * OrgFreedesktopUDisks::handle-linux-lvm2-lvstart:
2742    * @object: A #OrgFreedesktopUDisks.
2743    * @invocation: A #GDBusMethodInvocation.
2744    * @arg_group_uuid: Argument passed by remote caller.
2745    * @arg_uuid: Argument passed by remote caller.
2746    * @arg_options: Argument passed by remote caller.
2747    *
2748    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVStart">LinuxLvm2LVStart()</link> D-Bus method.
2749    *
2750    * 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 org_freedesktop_udisks_complete_linux_lvm2_lvstart() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2751    *
2752    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2753    */
2754   g_signal_new ("handle-linux-lvm2-lvstart",
2755     G_TYPE_FROM_INTERFACE (iface),
2756     G_SIGNAL_RUN_LAST,
2757     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_linux_lvm2_lvstart),
2758     g_signal_accumulator_true_handled,
2759     NULL,
2760     g_cclosure_marshal_generic,
2761     G_TYPE_BOOLEAN,
2762     4,
2763     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRV);
2764
2765   /**
2766    * OrgFreedesktopUDisks::handle-linux-lvm2-lvremove:
2767    * @object: A #OrgFreedesktopUDisks.
2768    * @invocation: A #GDBusMethodInvocation.
2769    * @arg_group_uuid: Argument passed by remote caller.
2770    * @arg_uuid: Argument passed by remote caller.
2771    * @arg_options: Argument passed by remote caller.
2772    *
2773    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVRemove">LinuxLvm2LVRemove()</link> D-Bus method.
2774    *
2775    * 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 org_freedesktop_udisks_complete_linux_lvm2_lvremove() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2776    *
2777    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2778    */
2779   g_signal_new ("handle-linux-lvm2-lvremove",
2780     G_TYPE_FROM_INTERFACE (iface),
2781     G_SIGNAL_RUN_LAST,
2782     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_linux_lvm2_lvremove),
2783     g_signal_accumulator_true_handled,
2784     NULL,
2785     g_cclosure_marshal_generic,
2786     G_TYPE_BOOLEAN,
2787     4,
2788     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_STRV);
2789
2790   /**
2791    * OrgFreedesktopUDisks::handle-linux-lvm2-lvcreate:
2792    * @object: A #OrgFreedesktopUDisks.
2793    * @invocation: A #GDBusMethodInvocation.
2794    * @arg_group_uuid: Argument passed by remote caller.
2795    * @arg_name: Argument passed by remote caller.
2796    * @arg_size: Argument passed by remote caller.
2797    * @arg_num_stripes: Argument passed by remote caller.
2798    * @arg_stripe_size: Argument passed by remote caller.
2799    * @arg_num_mirrors: Argument passed by remote caller.
2800    * @arg_options: Argument passed by remote caller.
2801    * @arg_fstype: Argument passed by remote caller.
2802    * @arg_fsoptions: Argument passed by remote caller.
2803    *
2804    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVCreate">LinuxLvm2LVCreate()</link> D-Bus method.
2805    *
2806    * 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 org_freedesktop_udisks_complete_linux_lvm2_lvcreate() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2807    *
2808    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2809    */
2810   g_signal_new ("handle-linux-lvm2-lvcreate",
2811     G_TYPE_FROM_INTERFACE (iface),
2812     G_SIGNAL_RUN_LAST,
2813     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_linux_lvm2_lvcreate),
2814     g_signal_accumulator_true_handled,
2815     NULL,
2816     g_cclosure_marshal_generic,
2817     G_TYPE_BOOLEAN,
2818     10,
2819     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_UINT, G_TYPE_UINT64, G_TYPE_UINT, G_TYPE_STRV, G_TYPE_STRING, G_TYPE_STRV);
2820
2821   /**
2822    * OrgFreedesktopUDisks::handle-linux-md-start:
2823    * @object: A #OrgFreedesktopUDisks.
2824    * @invocation: A #GDBusMethodInvocation.
2825    * @arg_components: Argument passed by remote caller.
2826    * @arg_options: Argument passed by remote caller.
2827    *
2828    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxMdStart">LinuxMdStart()</link> D-Bus method.
2829    *
2830    * 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 org_freedesktop_udisks_complete_linux_md_start() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2831    *
2832    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2833    */
2834   g_signal_new ("handle-linux-md-start",
2835     G_TYPE_FROM_INTERFACE (iface),
2836     G_SIGNAL_RUN_LAST,
2837     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_linux_md_start),
2838     g_signal_accumulator_true_handled,
2839     NULL,
2840     g_cclosure_marshal_generic,
2841     G_TYPE_BOOLEAN,
2842     3,
2843     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRV, G_TYPE_STRV);
2844
2845   /**
2846    * OrgFreedesktopUDisks::handle-linux-md-create:
2847    * @object: A #OrgFreedesktopUDisks.
2848    * @invocation: A #GDBusMethodInvocation.
2849    * @arg_components: Argument passed by remote caller.
2850    * @arg_level: Argument passed by remote caller.
2851    * @arg_stripe_size: Argument passed by remote caller.
2852    * @arg_name: Argument passed by remote caller.
2853    * @arg_options: Argument passed by remote caller.
2854    *
2855    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxMdCreate">LinuxMdCreate()</link> D-Bus method.
2856    *
2857    * 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 org_freedesktop_udisks_complete_linux_md_create() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2858    *
2859    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2860    */
2861   g_signal_new ("handle-linux-md-create",
2862     G_TYPE_FROM_INTERFACE (iface),
2863     G_SIGNAL_RUN_LAST,
2864     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_linux_md_create),
2865     g_signal_accumulator_true_handled,
2866     NULL,
2867     g_cclosure_marshal_generic,
2868     G_TYPE_BOOLEAN,
2869     6,
2870     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRV, G_TYPE_STRING, G_TYPE_UINT64, G_TYPE_STRING, G_TYPE_STRV);
2871
2872   /**
2873    * OrgFreedesktopUDisks::handle-inhibit:
2874    * @object: A #OrgFreedesktopUDisks.
2875    * @invocation: A #GDBusMethodInvocation.
2876    *
2877    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.Inhibit">Inhibit()</link> D-Bus method.
2878    *
2879    * 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 org_freedesktop_udisks_complete_inhibit() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2880    *
2881    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2882    */
2883   g_signal_new ("handle-inhibit",
2884     G_TYPE_FROM_INTERFACE (iface),
2885     G_SIGNAL_RUN_LAST,
2886     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_inhibit),
2887     g_signal_accumulator_true_handled,
2888     NULL,
2889     g_cclosure_marshal_generic,
2890     G_TYPE_BOOLEAN,
2891     1,
2892     G_TYPE_DBUS_METHOD_INVOCATION);
2893
2894   /**
2895    * OrgFreedesktopUDisks::handle-uninhibit:
2896    * @object: A #OrgFreedesktopUDisks.
2897    * @invocation: A #GDBusMethodInvocation.
2898    * @arg_cookie: Argument passed by remote caller.
2899    *
2900    * Signal emitted when a remote caller is invoking the <link linkend="gdbus-method-org-freedesktop-UDisks.Uninhibit">Uninhibit()</link> D-Bus method.
2901    *
2902    * 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 org_freedesktop_udisks_complete_uninhibit() or e.g. g_dbus_method_invocation_return_error() on it) and no order signal handlers will run. If no signal handler handles the invocation, the %G_DBUS_ERROR_UNKNOWN_METHOD error is returned.
2903    *
2904    * Returns: %TRUE if the invocation was handled, %FALSE to let other signal handlers run.
2905    */
2906   g_signal_new ("handle-uninhibit",
2907     G_TYPE_FROM_INTERFACE (iface),
2908     G_SIGNAL_RUN_LAST,
2909     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, handle_uninhibit),
2910     g_signal_accumulator_true_handled,
2911     NULL,
2912     g_cclosure_marshal_generic,
2913     G_TYPE_BOOLEAN,
2914     2,
2915     G_TYPE_DBUS_METHOD_INVOCATION, G_TYPE_STRING);
2916
2917   /* GObject signals for received D-Bus signals: */
2918   /**
2919    * OrgFreedesktopUDisks::device-added:
2920    * @object: A #OrgFreedesktopUDisks.
2921    * @arg_device: Argument.
2922    *
2923    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks.DeviceAdded">"DeviceAdded"</link> is received.
2924    *
2925    * 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.
2926    */
2927   g_signal_new ("device-added",
2928     G_TYPE_FROM_INTERFACE (iface),
2929     G_SIGNAL_RUN_LAST,
2930     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, device_added),
2931     NULL,
2932     NULL,
2933     g_cclosure_marshal_generic,
2934     G_TYPE_NONE,
2935     1, G_TYPE_STRING);
2936
2937   /**
2938    * OrgFreedesktopUDisks::device-removed:
2939    * @object: A #OrgFreedesktopUDisks.
2940    * @arg_device: Argument.
2941    *
2942    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks.DeviceRemoved">"DeviceRemoved"</link> is received.
2943    *
2944    * 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.
2945    */
2946   g_signal_new ("device-removed",
2947     G_TYPE_FROM_INTERFACE (iface),
2948     G_SIGNAL_RUN_LAST,
2949     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, device_removed),
2950     NULL,
2951     NULL,
2952     g_cclosure_marshal_generic,
2953     G_TYPE_NONE,
2954     1, G_TYPE_STRING);
2955
2956   /**
2957    * OrgFreedesktopUDisks::device-changed:
2958    * @object: A #OrgFreedesktopUDisks.
2959    * @arg_device: Argument.
2960    *
2961    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks.DeviceChanged">"DeviceChanged"</link> is received.
2962    *
2963    * 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.
2964    */
2965   g_signal_new ("device-changed",
2966     G_TYPE_FROM_INTERFACE (iface),
2967     G_SIGNAL_RUN_LAST,
2968     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, device_changed),
2969     NULL,
2970     NULL,
2971     g_cclosure_marshal_generic,
2972     G_TYPE_NONE,
2973     1, G_TYPE_STRING);
2974
2975   /**
2976    * OrgFreedesktopUDisks::device-job-changed:
2977    * @object: A #OrgFreedesktopUDisks.
2978    * @arg_device: Argument.
2979    * @arg_job_in_progress: Argument.
2980    * @arg_job_is_cancellable: Argument.
2981    * @arg_job_id: Argument.
2982    * @arg_job_num_tasks: Argument.
2983    * @arg_job_cur_task: Argument.
2984    * @arg_job_cur_task_id: Argument.
2985    * @arg_job_cur_task_percentage: Argument.
2986    *
2987    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks.DeviceJobChanged">"DeviceJobChanged"</link> is received.
2988    *
2989    * 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.
2990    */
2991   g_signal_new ("device-job-changed",
2992     G_TYPE_FROM_INTERFACE (iface),
2993     G_SIGNAL_RUN_LAST,
2994     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, device_job_changed),
2995     NULL,
2996     NULL,
2997     g_cclosure_marshal_generic,
2998     G_TYPE_NONE,
2999     8, G_TYPE_STRING, G_TYPE_BOOLEAN, G_TYPE_BOOLEAN, G_TYPE_STRING, G_TYPE_INT, G_TYPE_INT, G_TYPE_STRING, G_TYPE_DOUBLE);
3000
3001   /**
3002    * OrgFreedesktopUDisks::adapter-added:
3003    * @object: A #OrgFreedesktopUDisks.
3004    * @arg_adapter: Argument.
3005    *
3006    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks.AdapterAdded">"AdapterAdded"</link> is received.
3007    *
3008    * 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.
3009    */
3010   g_signal_new ("adapter-added",
3011     G_TYPE_FROM_INTERFACE (iface),
3012     G_SIGNAL_RUN_LAST,
3013     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, adapter_added),
3014     NULL,
3015     NULL,
3016     g_cclosure_marshal_generic,
3017     G_TYPE_NONE,
3018     1, G_TYPE_STRING);
3019
3020   /**
3021    * OrgFreedesktopUDisks::adapter-removed:
3022    * @object: A #OrgFreedesktopUDisks.
3023    * @arg_adapter: Argument.
3024    *
3025    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks.AdapterRemoved">"AdapterRemoved"</link> is received.
3026    *
3027    * 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.
3028    */
3029   g_signal_new ("adapter-removed",
3030     G_TYPE_FROM_INTERFACE (iface),
3031     G_SIGNAL_RUN_LAST,
3032     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, adapter_removed),
3033     NULL,
3034     NULL,
3035     g_cclosure_marshal_generic,
3036     G_TYPE_NONE,
3037     1, G_TYPE_STRING);
3038
3039   /**
3040    * OrgFreedesktopUDisks::adapter-changed:
3041    * @object: A #OrgFreedesktopUDisks.
3042    * @arg_adapter: Argument.
3043    *
3044    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks.AdapterChanged">"AdapterChanged"</link> is received.
3045    *
3046    * 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.
3047    */
3048   g_signal_new ("adapter-changed",
3049     G_TYPE_FROM_INTERFACE (iface),
3050     G_SIGNAL_RUN_LAST,
3051     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, adapter_changed),
3052     NULL,
3053     NULL,
3054     g_cclosure_marshal_generic,
3055     G_TYPE_NONE,
3056     1, G_TYPE_STRING);
3057
3058   /**
3059    * OrgFreedesktopUDisks::expander-added:
3060    * @object: A #OrgFreedesktopUDisks.
3061    * @arg_expander: Argument.
3062    *
3063    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks.ExpanderAdded">"ExpanderAdded"</link> is received.
3064    *
3065    * 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.
3066    */
3067   g_signal_new ("expander-added",
3068     G_TYPE_FROM_INTERFACE (iface),
3069     G_SIGNAL_RUN_LAST,
3070     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, expander_added),
3071     NULL,
3072     NULL,
3073     g_cclosure_marshal_generic,
3074     G_TYPE_NONE,
3075     1, G_TYPE_STRING);
3076
3077   /**
3078    * OrgFreedesktopUDisks::expander-removed:
3079    * @object: A #OrgFreedesktopUDisks.
3080    * @arg_expander: Argument.
3081    *
3082    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks.ExpanderRemoved">"ExpanderRemoved"</link> is received.
3083    *
3084    * 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.
3085    */
3086   g_signal_new ("expander-removed",
3087     G_TYPE_FROM_INTERFACE (iface),
3088     G_SIGNAL_RUN_LAST,
3089     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, expander_removed),
3090     NULL,
3091     NULL,
3092     g_cclosure_marshal_generic,
3093     G_TYPE_NONE,
3094     1, G_TYPE_STRING);
3095
3096   /**
3097    * OrgFreedesktopUDisks::expander-changed:
3098    * @object: A #OrgFreedesktopUDisks.
3099    * @arg_expander: Argument.
3100    *
3101    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks.ExpanderChanged">"ExpanderChanged"</link> is received.
3102    *
3103    * 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.
3104    */
3105   g_signal_new ("expander-changed",
3106     G_TYPE_FROM_INTERFACE (iface),
3107     G_SIGNAL_RUN_LAST,
3108     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, expander_changed),
3109     NULL,
3110     NULL,
3111     g_cclosure_marshal_generic,
3112     G_TYPE_NONE,
3113     1, G_TYPE_STRING);
3114
3115   /**
3116    * OrgFreedesktopUDisks::port-added:
3117    * @object: A #OrgFreedesktopUDisks.
3118    * @arg_port: Argument.
3119    *
3120    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks.PortAdded">"PortAdded"</link> is received.
3121    *
3122    * 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.
3123    */
3124   g_signal_new ("port-added",
3125     G_TYPE_FROM_INTERFACE (iface),
3126     G_SIGNAL_RUN_LAST,
3127     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, port_added),
3128     NULL,
3129     NULL,
3130     g_cclosure_marshal_generic,
3131     G_TYPE_NONE,
3132     1, G_TYPE_STRING);
3133
3134   /**
3135    * OrgFreedesktopUDisks::port-removed:
3136    * @object: A #OrgFreedesktopUDisks.
3137    * @arg_port: Argument.
3138    *
3139    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks.PortRemoved">"PortRemoved"</link> is received.
3140    *
3141    * 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.
3142    */
3143   g_signal_new ("port-removed",
3144     G_TYPE_FROM_INTERFACE (iface),
3145     G_SIGNAL_RUN_LAST,
3146     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, port_removed),
3147     NULL,
3148     NULL,
3149     g_cclosure_marshal_generic,
3150     G_TYPE_NONE,
3151     1, G_TYPE_STRING);
3152
3153   /**
3154    * OrgFreedesktopUDisks::port-changed:
3155    * @object: A #OrgFreedesktopUDisks.
3156    * @arg_port: Argument.
3157    *
3158    * On the client-side, this signal is emitted whenever the D-Bus signal <link linkend="gdbus-signal-org-freedesktop-UDisks.PortChanged">"PortChanged"</link> is received.
3159    *
3160    * 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.
3161    */
3162   g_signal_new ("port-changed",
3163     G_TYPE_FROM_INTERFACE (iface),
3164     G_SIGNAL_RUN_LAST,
3165     G_STRUCT_OFFSET (OrgFreedesktopUDisksIface, port_changed),
3166     NULL,
3167     NULL,
3168     g_cclosure_marshal_generic,
3169     G_TYPE_NONE,
3170     1, G_TYPE_STRING);
3171
3172   /* GObject properties for D-Bus properties: */
3173   /**
3174    * OrgFreedesktopUDisks:daemon-version:
3175    *
3176    * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks.DaemonVersion">"DaemonVersion"</link>.
3177    *
3178    * 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.
3179    */
3180   g_object_interface_install_property (iface,
3181     g_param_spec_string ("daemon-version", "DaemonVersion", "DaemonVersion", NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
3182   /**
3183    * OrgFreedesktopUDisks:daemon-is-inhibited:
3184    *
3185    * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks.DaemonIsInhibited">"DaemonIsInhibited"</link>.
3186    *
3187    * 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.
3188    */
3189   g_object_interface_install_property (iface,
3190     g_param_spec_boolean ("daemon-is-inhibited", "DaemonIsInhibited", "DaemonIsInhibited", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
3191   /**
3192    * OrgFreedesktopUDisks:supports-luks-devices:
3193    *
3194    * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks.SupportsLuksDevices">"SupportsLuksDevices"</link>.
3195    *
3196    * 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.
3197    */
3198   g_object_interface_install_property (iface,
3199     g_param_spec_boolean ("supports-luks-devices", "SupportsLuksDevices", "SupportsLuksDevices", FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
3200   /**
3201    * OrgFreedesktopUDisks:known-filesystems:
3202    *
3203    * Represents the D-Bus property <link linkend="gdbus-property-org-freedesktop-UDisks.KnownFilesystems">"KnownFilesystems"</link>.
3204    *
3205    * 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.
3206    */
3207   g_object_interface_install_property (iface,
3208     g_param_spec_variant ("known-filesystems", "KnownFilesystems", "KnownFilesystems", G_VARIANT_TYPE ("a(ssbbbubbbbbbbb)"), NULL, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
3209 }
3210
3211 /**
3212  * org_freedesktop_udisks_get_daemon_version: (skip)
3213  * @object: A #OrgFreedesktopUDisks.
3214  *
3215  * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks.DaemonVersion">"DaemonVersion"</link> D-Bus property.
3216  *
3217  * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
3218  *
3219  * <warning>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 org_freedesktop_udisks_dup_daemon_version() if on another thread.</warning>
3220  *
3221  * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
3222  */
3223 const gchar *
3224 org_freedesktop_udisks_get_daemon_version (OrgFreedesktopUDisks *object)
3225 {
3226   return ORG_FREEDESKTOP_UDISKS_GET_IFACE (object)->get_daemon_version (object);
3227 }
3228
3229 /**
3230  * org_freedesktop_udisks_dup_daemon_version: (skip)
3231  * @object: A #OrgFreedesktopUDisks.
3232  *
3233  * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks.DaemonVersion">"DaemonVersion"</link> D-Bus property.
3234  *
3235  * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
3236  *
3237  * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_free().
3238  */
3239 gchar *
3240 org_freedesktop_udisks_dup_daemon_version (OrgFreedesktopUDisks *object)
3241 {
3242   gchar *value;
3243   g_object_get (G_OBJECT (object), "daemon-version", &value, NULL);
3244   return value;
3245 }
3246
3247 /**
3248  * org_freedesktop_udisks_set_daemon_version: (skip)
3249  * @object: A #OrgFreedesktopUDisks.
3250  * @value: The value to set.
3251  *
3252  * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks.DaemonVersion">"DaemonVersion"</link> D-Bus property to @value.
3253  *
3254  * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
3255  */
3256 void
3257 org_freedesktop_udisks_set_daemon_version (OrgFreedesktopUDisks *object, const gchar *value)
3258 {
3259   g_object_set (G_OBJECT (object), "daemon-version", value, NULL);
3260 }
3261
3262 /**
3263  * org_freedesktop_udisks_get_daemon_is_inhibited: (skip)
3264  * @object: A #OrgFreedesktopUDisks.
3265  *
3266  * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks.DaemonIsInhibited">"DaemonIsInhibited"</link> D-Bus property.
3267  *
3268  * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
3269  *
3270  * Returns: The property value.
3271  */
3272 gboolean
3273 org_freedesktop_udisks_get_daemon_is_inhibited (OrgFreedesktopUDisks *object)
3274 {
3275   return ORG_FREEDESKTOP_UDISKS_GET_IFACE (object)->get_daemon_is_inhibited (object);
3276 }
3277
3278 /**
3279  * org_freedesktop_udisks_set_daemon_is_inhibited: (skip)
3280  * @object: A #OrgFreedesktopUDisks.
3281  * @value: The value to set.
3282  *
3283  * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks.DaemonIsInhibited">"DaemonIsInhibited"</link> D-Bus property to @value.
3284  *
3285  * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
3286  */
3287 void
3288 org_freedesktop_udisks_set_daemon_is_inhibited (OrgFreedesktopUDisks *object, gboolean value)
3289 {
3290   g_object_set (G_OBJECT (object), "daemon-is-inhibited", value, NULL);
3291 }
3292
3293 /**
3294  * org_freedesktop_udisks_get_supports_luks_devices: (skip)
3295  * @object: A #OrgFreedesktopUDisks.
3296  *
3297  * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks.SupportsLuksDevices">"SupportsLuksDevices"</link> D-Bus property.
3298  *
3299  * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
3300  *
3301  * Returns: The property value.
3302  */
3303 gboolean
3304 org_freedesktop_udisks_get_supports_luks_devices (OrgFreedesktopUDisks *object)
3305 {
3306   return ORG_FREEDESKTOP_UDISKS_GET_IFACE (object)->get_supports_luks_devices (object);
3307 }
3308
3309 /**
3310  * org_freedesktop_udisks_set_supports_luks_devices: (skip)
3311  * @object: A #OrgFreedesktopUDisks.
3312  * @value: The value to set.
3313  *
3314  * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks.SupportsLuksDevices">"SupportsLuksDevices"</link> D-Bus property to @value.
3315  *
3316  * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
3317  */
3318 void
3319 org_freedesktop_udisks_set_supports_luks_devices (OrgFreedesktopUDisks *object, gboolean value)
3320 {
3321   g_object_set (G_OBJECT (object), "supports-luks-devices", value, NULL);
3322 }
3323
3324 /**
3325  * org_freedesktop_udisks_get_known_filesystems: (skip)
3326  * @object: A #OrgFreedesktopUDisks.
3327  *
3328  * Gets the value of the <link linkend="gdbus-property-org-freedesktop-UDisks.KnownFilesystems">"KnownFilesystems"</link> D-Bus property.
3329  *
3330  * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
3331  *
3332  * <warning>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 org_freedesktop_udisks_dup_known_filesystems() if on another thread.</warning>
3333  *
3334  * Returns: (transfer none): The property value or %NULL if the property is not set. Do not free the returned value, it belongs to @object.
3335  */
3336 GVariant *
3337 org_freedesktop_udisks_get_known_filesystems (OrgFreedesktopUDisks *object)
3338 {
3339   return ORG_FREEDESKTOP_UDISKS_GET_IFACE (object)->get_known_filesystems (object);
3340 }
3341
3342 /**
3343  * org_freedesktop_udisks_dup_known_filesystems: (skip)
3344  * @object: A #OrgFreedesktopUDisks.
3345  *
3346  * Gets a copy of the <link linkend="gdbus-property-org-freedesktop-UDisks.KnownFilesystems">"KnownFilesystems"</link> D-Bus property.
3347  *
3348  * Since this D-Bus property is readable, it is meaningful to use this function on both the client- and service-side.
3349  *
3350  * Returns: (transfer full): The property value or %NULL if the property is not set. The returned value should be freed with g_variant_unref().
3351  */
3352 GVariant *
3353 org_freedesktop_udisks_dup_known_filesystems (OrgFreedesktopUDisks *object)
3354 {
3355   GVariant *value;
3356   g_object_get (G_OBJECT (object), "known-filesystems", &value, NULL);
3357   return value;
3358 }
3359
3360 /**
3361  * org_freedesktop_udisks_set_known_filesystems: (skip)
3362  * @object: A #OrgFreedesktopUDisks.
3363  * @value: The value to set.
3364  *
3365  * Sets the <link linkend="gdbus-property-org-freedesktop-UDisks.KnownFilesystems">"KnownFilesystems"</link> D-Bus property to @value.
3366  *
3367  * Since this D-Bus property is not writable, it is only meaningful to use this function on the service-side.
3368  */
3369 void
3370 org_freedesktop_udisks_set_known_filesystems (OrgFreedesktopUDisks *object, GVariant *value)
3371 {
3372   g_object_set (G_OBJECT (object), "known-filesystems", value, NULL);
3373 }
3374
3375 /**
3376  * org_freedesktop_udisks_emit_device_added:
3377  * @object: A #OrgFreedesktopUDisks.
3378  * @arg_device: Argument to pass with the signal.
3379  *
3380  * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks.DeviceAdded">"DeviceAdded"</link> D-Bus signal.
3381  */
3382 void
3383 org_freedesktop_udisks_emit_device_added (
3384     OrgFreedesktopUDisks *object,
3385     const gchar *arg_device)
3386 {
3387   g_signal_emit_by_name (object, "device-added", arg_device);
3388 }
3389
3390 /**
3391  * org_freedesktop_udisks_emit_device_removed:
3392  * @object: A #OrgFreedesktopUDisks.
3393  * @arg_device: Argument to pass with the signal.
3394  *
3395  * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks.DeviceRemoved">"DeviceRemoved"</link> D-Bus signal.
3396  */
3397 void
3398 org_freedesktop_udisks_emit_device_removed (
3399     OrgFreedesktopUDisks *object,
3400     const gchar *arg_device)
3401 {
3402   g_signal_emit_by_name (object, "device-removed", arg_device);
3403 }
3404
3405 /**
3406  * org_freedesktop_udisks_emit_device_changed:
3407  * @object: A #OrgFreedesktopUDisks.
3408  * @arg_device: Argument to pass with the signal.
3409  *
3410  * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks.DeviceChanged">"DeviceChanged"</link> D-Bus signal.
3411  */
3412 void
3413 org_freedesktop_udisks_emit_device_changed (
3414     OrgFreedesktopUDisks *object,
3415     const gchar *arg_device)
3416 {
3417   g_signal_emit_by_name (object, "device-changed", arg_device);
3418 }
3419
3420 /**
3421  * org_freedesktop_udisks_emit_device_job_changed:
3422  * @object: A #OrgFreedesktopUDisks.
3423  * @arg_device: Argument to pass with the signal.
3424  * @arg_job_in_progress: Argument to pass with the signal.
3425  * @arg_job_is_cancellable: Argument to pass with the signal.
3426  * @arg_job_id: Argument to pass with the signal.
3427  * @arg_job_num_tasks: Argument to pass with the signal.
3428  * @arg_job_cur_task: Argument to pass with the signal.
3429  * @arg_job_cur_task_id: Argument to pass with the signal.
3430  * @arg_job_cur_task_percentage: Argument to pass with the signal.
3431  *
3432  * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks.DeviceJobChanged">"DeviceJobChanged"</link> D-Bus signal.
3433  */
3434 void
3435 org_freedesktop_udisks_emit_device_job_changed (
3436     OrgFreedesktopUDisks *object,
3437     const gchar *arg_device,
3438     gboolean arg_job_in_progress,
3439     gboolean arg_job_is_cancellable,
3440     const gchar *arg_job_id,
3441     gint arg_job_num_tasks,
3442     gint arg_job_cur_task,
3443     const gchar *arg_job_cur_task_id,
3444     gdouble arg_job_cur_task_percentage)
3445 {
3446   g_signal_emit_by_name (object, "device-job-changed", arg_device, arg_job_in_progress, arg_job_is_cancellable, arg_job_id, arg_job_num_tasks, arg_job_cur_task, arg_job_cur_task_id, arg_job_cur_task_percentage);
3447 }
3448
3449 /**
3450  * org_freedesktop_udisks_emit_adapter_added:
3451  * @object: A #OrgFreedesktopUDisks.
3452  * @arg_adapter: Argument to pass with the signal.
3453  *
3454  * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks.AdapterAdded">"AdapterAdded"</link> D-Bus signal.
3455  */
3456 void
3457 org_freedesktop_udisks_emit_adapter_added (
3458     OrgFreedesktopUDisks *object,
3459     const gchar *arg_adapter)
3460 {
3461   g_signal_emit_by_name (object, "adapter-added", arg_adapter);
3462 }
3463
3464 /**
3465  * org_freedesktop_udisks_emit_adapter_removed:
3466  * @object: A #OrgFreedesktopUDisks.
3467  * @arg_adapter: Argument to pass with the signal.
3468  *
3469  * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks.AdapterRemoved">"AdapterRemoved"</link> D-Bus signal.
3470  */
3471 void
3472 org_freedesktop_udisks_emit_adapter_removed (
3473     OrgFreedesktopUDisks *object,
3474     const gchar *arg_adapter)
3475 {
3476   g_signal_emit_by_name (object, "adapter-removed", arg_adapter);
3477 }
3478
3479 /**
3480  * org_freedesktop_udisks_emit_adapter_changed:
3481  * @object: A #OrgFreedesktopUDisks.
3482  * @arg_adapter: Argument to pass with the signal.
3483  *
3484  * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks.AdapterChanged">"AdapterChanged"</link> D-Bus signal.
3485  */
3486 void
3487 org_freedesktop_udisks_emit_adapter_changed (
3488     OrgFreedesktopUDisks *object,
3489     const gchar *arg_adapter)
3490 {
3491   g_signal_emit_by_name (object, "adapter-changed", arg_adapter);
3492 }
3493
3494 /**
3495  * org_freedesktop_udisks_emit_expander_added:
3496  * @object: A #OrgFreedesktopUDisks.
3497  * @arg_expander: Argument to pass with the signal.
3498  *
3499  * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks.ExpanderAdded">"ExpanderAdded"</link> D-Bus signal.
3500  */
3501 void
3502 org_freedesktop_udisks_emit_expander_added (
3503     OrgFreedesktopUDisks *object,
3504     const gchar *arg_expander)
3505 {
3506   g_signal_emit_by_name (object, "expander-added", arg_expander);
3507 }
3508
3509 /**
3510  * org_freedesktop_udisks_emit_expander_removed:
3511  * @object: A #OrgFreedesktopUDisks.
3512  * @arg_expander: Argument to pass with the signal.
3513  *
3514  * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks.ExpanderRemoved">"ExpanderRemoved"</link> D-Bus signal.
3515  */
3516 void
3517 org_freedesktop_udisks_emit_expander_removed (
3518     OrgFreedesktopUDisks *object,
3519     const gchar *arg_expander)
3520 {
3521   g_signal_emit_by_name (object, "expander-removed", arg_expander);
3522 }
3523
3524 /**
3525  * org_freedesktop_udisks_emit_expander_changed:
3526  * @object: A #OrgFreedesktopUDisks.
3527  * @arg_expander: Argument to pass with the signal.
3528  *
3529  * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks.ExpanderChanged">"ExpanderChanged"</link> D-Bus signal.
3530  */
3531 void
3532 org_freedesktop_udisks_emit_expander_changed (
3533     OrgFreedesktopUDisks *object,
3534     const gchar *arg_expander)
3535 {
3536   g_signal_emit_by_name (object, "expander-changed", arg_expander);
3537 }
3538
3539 /**
3540  * org_freedesktop_udisks_emit_port_added:
3541  * @object: A #OrgFreedesktopUDisks.
3542  * @arg_port: Argument to pass with the signal.
3543  *
3544  * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks.PortAdded">"PortAdded"</link> D-Bus signal.
3545  */
3546 void
3547 org_freedesktop_udisks_emit_port_added (
3548     OrgFreedesktopUDisks *object,
3549     const gchar *arg_port)
3550 {
3551   g_signal_emit_by_name (object, "port-added", arg_port);
3552 }
3553
3554 /**
3555  * org_freedesktop_udisks_emit_port_removed:
3556  * @object: A #OrgFreedesktopUDisks.
3557  * @arg_port: Argument to pass with the signal.
3558  *
3559  * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks.PortRemoved">"PortRemoved"</link> D-Bus signal.
3560  */
3561 void
3562 org_freedesktop_udisks_emit_port_removed (
3563     OrgFreedesktopUDisks *object,
3564     const gchar *arg_port)
3565 {
3566   g_signal_emit_by_name (object, "port-removed", arg_port);
3567 }
3568
3569 /**
3570  * org_freedesktop_udisks_emit_port_changed:
3571  * @object: A #OrgFreedesktopUDisks.
3572  * @arg_port: Argument to pass with the signal.
3573  *
3574  * Emits the <link linkend="gdbus-signal-org-freedesktop-UDisks.PortChanged">"PortChanged"</link> D-Bus signal.
3575  */
3576 void
3577 org_freedesktop_udisks_emit_port_changed (
3578     OrgFreedesktopUDisks *object,
3579     const gchar *arg_port)
3580 {
3581   g_signal_emit_by_name (object, "port-changed", arg_port);
3582 }
3583
3584 /**
3585  * org_freedesktop_udisks_call_enumerate_adapters:
3586  * @proxy: A #OrgFreedesktopUDisksProxy.
3587  * @cancellable: (allow-none): A #GCancellable or %NULL.
3588  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
3589  * @user_data: User data to pass to @callback.
3590  *
3591  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateAdapters">EnumerateAdapters()</link> D-Bus method on @proxy.
3592  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
3593  * You can then call org_freedesktop_udisks_call_enumerate_adapters_finish() to get the result of the operation.
3594  *
3595  * See org_freedesktop_udisks_call_enumerate_adapters_sync() for the synchronous, blocking version of this method.
3596  */
3597 void
3598 org_freedesktop_udisks_call_enumerate_adapters (
3599     OrgFreedesktopUDisks *proxy,
3600     GCancellable *cancellable,
3601     GAsyncReadyCallback callback,
3602     gpointer user_data)
3603 {
3604   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
3605     "EnumerateAdapters",
3606     g_variant_new ("()"),
3607     G_DBUS_CALL_FLAGS_NONE,
3608     -1,
3609     cancellable,
3610     callback,
3611     user_data);
3612 }
3613
3614 /**
3615  * org_freedesktop_udisks_call_enumerate_adapters_finish:
3616  * @proxy: A #OrgFreedesktopUDisksProxy.
3617  * @out_devices: (out): Return location for return parameter or %NULL to ignore.
3618  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_enumerate_adapters().
3619  * @error: Return location for error or %NULL.
3620  *
3621  * Finishes an operation started with org_freedesktop_udisks_call_enumerate_adapters().
3622  *
3623  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
3624  */
3625 gboolean
3626 org_freedesktop_udisks_call_enumerate_adapters_finish (
3627     OrgFreedesktopUDisks *proxy,
3628     gchar ***out_devices,
3629     GAsyncResult *res,
3630     GError **error)
3631 {
3632   GVariant *_ret;
3633   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
3634   if (_ret == NULL)
3635     goto _out;
3636   g_variant_get (_ret,
3637                  "(^ao)",
3638                  out_devices);
3639   g_variant_unref (_ret);
3640 _out:
3641   return _ret != NULL;
3642 }
3643
3644 /**
3645  * org_freedesktop_udisks_call_enumerate_adapters_sync:
3646  * @proxy: A #OrgFreedesktopUDisksProxy.
3647  * @out_devices: (out): Return location for return parameter or %NULL to ignore.
3648  * @cancellable: (allow-none): A #GCancellable or %NULL.
3649  * @error: Return location for error or %NULL.
3650  *
3651  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateAdapters">EnumerateAdapters()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
3652  *
3653  * See org_freedesktop_udisks_call_enumerate_adapters() for the asynchronous version of this method.
3654  *
3655  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
3656  */
3657 gboolean
3658 org_freedesktop_udisks_call_enumerate_adapters_sync (
3659     OrgFreedesktopUDisks *proxy,
3660     gchar ***out_devices,
3661     GCancellable *cancellable,
3662     GError **error)
3663 {
3664   GVariant *_ret;
3665   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
3666     "EnumerateAdapters",
3667     g_variant_new ("()"),
3668     G_DBUS_CALL_FLAGS_NONE,
3669     -1,
3670     cancellable,
3671     error);
3672   if (_ret == NULL)
3673     goto _out;
3674   g_variant_get (_ret,
3675                  "(^ao)",
3676                  out_devices);
3677   g_variant_unref (_ret);
3678 _out:
3679   return _ret != NULL;
3680 }
3681
3682 /**
3683  * org_freedesktop_udisks_call_enumerate_expanders:
3684  * @proxy: A #OrgFreedesktopUDisksProxy.
3685  * @cancellable: (allow-none): A #GCancellable or %NULL.
3686  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
3687  * @user_data: User data to pass to @callback.
3688  *
3689  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateExpanders">EnumerateExpanders()</link> D-Bus method on @proxy.
3690  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
3691  * You can then call org_freedesktop_udisks_call_enumerate_expanders_finish() to get the result of the operation.
3692  *
3693  * See org_freedesktop_udisks_call_enumerate_expanders_sync() for the synchronous, blocking version of this method.
3694  */
3695 void
3696 org_freedesktop_udisks_call_enumerate_expanders (
3697     OrgFreedesktopUDisks *proxy,
3698     GCancellable *cancellable,
3699     GAsyncReadyCallback callback,
3700     gpointer user_data)
3701 {
3702   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
3703     "EnumerateExpanders",
3704     g_variant_new ("()"),
3705     G_DBUS_CALL_FLAGS_NONE,
3706     -1,
3707     cancellable,
3708     callback,
3709     user_data);
3710 }
3711
3712 /**
3713  * org_freedesktop_udisks_call_enumerate_expanders_finish:
3714  * @proxy: A #OrgFreedesktopUDisksProxy.
3715  * @out_devices: (out): Return location for return parameter or %NULL to ignore.
3716  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_enumerate_expanders().
3717  * @error: Return location for error or %NULL.
3718  *
3719  * Finishes an operation started with org_freedesktop_udisks_call_enumerate_expanders().
3720  *
3721  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
3722  */
3723 gboolean
3724 org_freedesktop_udisks_call_enumerate_expanders_finish (
3725     OrgFreedesktopUDisks *proxy,
3726     gchar ***out_devices,
3727     GAsyncResult *res,
3728     GError **error)
3729 {
3730   GVariant *_ret;
3731   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
3732   if (_ret == NULL)
3733     goto _out;
3734   g_variant_get (_ret,
3735                  "(^ao)",
3736                  out_devices);
3737   g_variant_unref (_ret);
3738 _out:
3739   return _ret != NULL;
3740 }
3741
3742 /**
3743  * org_freedesktop_udisks_call_enumerate_expanders_sync:
3744  * @proxy: A #OrgFreedesktopUDisksProxy.
3745  * @out_devices: (out): Return location for return parameter or %NULL to ignore.
3746  * @cancellable: (allow-none): A #GCancellable or %NULL.
3747  * @error: Return location for error or %NULL.
3748  *
3749  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateExpanders">EnumerateExpanders()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
3750  *
3751  * See org_freedesktop_udisks_call_enumerate_expanders() for the asynchronous version of this method.
3752  *
3753  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
3754  */
3755 gboolean
3756 org_freedesktop_udisks_call_enumerate_expanders_sync (
3757     OrgFreedesktopUDisks *proxy,
3758     gchar ***out_devices,
3759     GCancellable *cancellable,
3760     GError **error)
3761 {
3762   GVariant *_ret;
3763   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
3764     "EnumerateExpanders",
3765     g_variant_new ("()"),
3766     G_DBUS_CALL_FLAGS_NONE,
3767     -1,
3768     cancellable,
3769     error);
3770   if (_ret == NULL)
3771     goto _out;
3772   g_variant_get (_ret,
3773                  "(^ao)",
3774                  out_devices);
3775   g_variant_unref (_ret);
3776 _out:
3777   return _ret != NULL;
3778 }
3779
3780 /**
3781  * org_freedesktop_udisks_call_enumerate_ports:
3782  * @proxy: A #OrgFreedesktopUDisksProxy.
3783  * @cancellable: (allow-none): A #GCancellable or %NULL.
3784  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
3785  * @user_data: User data to pass to @callback.
3786  *
3787  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumeratePorts">EnumeratePorts()</link> D-Bus method on @proxy.
3788  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
3789  * You can then call org_freedesktop_udisks_call_enumerate_ports_finish() to get the result of the operation.
3790  *
3791  * See org_freedesktop_udisks_call_enumerate_ports_sync() for the synchronous, blocking version of this method.
3792  */
3793 void
3794 org_freedesktop_udisks_call_enumerate_ports (
3795     OrgFreedesktopUDisks *proxy,
3796     GCancellable *cancellable,
3797     GAsyncReadyCallback callback,
3798     gpointer user_data)
3799 {
3800   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
3801     "EnumeratePorts",
3802     g_variant_new ("()"),
3803     G_DBUS_CALL_FLAGS_NONE,
3804     -1,
3805     cancellable,
3806     callback,
3807     user_data);
3808 }
3809
3810 /**
3811  * org_freedesktop_udisks_call_enumerate_ports_finish:
3812  * @proxy: A #OrgFreedesktopUDisksProxy.
3813  * @out_devices: (out): Return location for return parameter or %NULL to ignore.
3814  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_enumerate_ports().
3815  * @error: Return location for error or %NULL.
3816  *
3817  * Finishes an operation started with org_freedesktop_udisks_call_enumerate_ports().
3818  *
3819  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
3820  */
3821 gboolean
3822 org_freedesktop_udisks_call_enumerate_ports_finish (
3823     OrgFreedesktopUDisks *proxy,
3824     gchar ***out_devices,
3825     GAsyncResult *res,
3826     GError **error)
3827 {
3828   GVariant *_ret;
3829   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
3830   if (_ret == NULL)
3831     goto _out;
3832   g_variant_get (_ret,
3833                  "(^ao)",
3834                  out_devices);
3835   g_variant_unref (_ret);
3836 _out:
3837   return _ret != NULL;
3838 }
3839
3840 /**
3841  * org_freedesktop_udisks_call_enumerate_ports_sync:
3842  * @proxy: A #OrgFreedesktopUDisksProxy.
3843  * @out_devices: (out): Return location for return parameter or %NULL to ignore.
3844  * @cancellable: (allow-none): A #GCancellable or %NULL.
3845  * @error: Return location for error or %NULL.
3846  *
3847  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumeratePorts">EnumeratePorts()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
3848  *
3849  * See org_freedesktop_udisks_call_enumerate_ports() for the asynchronous version of this method.
3850  *
3851  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
3852  */
3853 gboolean
3854 org_freedesktop_udisks_call_enumerate_ports_sync (
3855     OrgFreedesktopUDisks *proxy,
3856     gchar ***out_devices,
3857     GCancellable *cancellable,
3858     GError **error)
3859 {
3860   GVariant *_ret;
3861   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
3862     "EnumeratePorts",
3863     g_variant_new ("()"),
3864     G_DBUS_CALL_FLAGS_NONE,
3865     -1,
3866     cancellable,
3867     error);
3868   if (_ret == NULL)
3869     goto _out;
3870   g_variant_get (_ret,
3871                  "(^ao)",
3872                  out_devices);
3873   g_variant_unref (_ret);
3874 _out:
3875   return _ret != NULL;
3876 }
3877
3878 /**
3879  * org_freedesktop_udisks_call_enumerate_devices:
3880  * @proxy: A #OrgFreedesktopUDisksProxy.
3881  * @cancellable: (allow-none): A #GCancellable or %NULL.
3882  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
3883  * @user_data: User data to pass to @callback.
3884  *
3885  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateDevices">EnumerateDevices()</link> D-Bus method on @proxy.
3886  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
3887  * You can then call org_freedesktop_udisks_call_enumerate_devices_finish() to get the result of the operation.
3888  *
3889  * See org_freedesktop_udisks_call_enumerate_devices_sync() for the synchronous, blocking version of this method.
3890  */
3891 void
3892 org_freedesktop_udisks_call_enumerate_devices (
3893     OrgFreedesktopUDisks *proxy,
3894     GCancellable *cancellable,
3895     GAsyncReadyCallback callback,
3896     gpointer user_data)
3897 {
3898   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
3899     "EnumerateDevices",
3900     g_variant_new ("()"),
3901     G_DBUS_CALL_FLAGS_NONE,
3902     -1,
3903     cancellable,
3904     callback,
3905     user_data);
3906 }
3907
3908 /**
3909  * org_freedesktop_udisks_call_enumerate_devices_finish:
3910  * @proxy: A #OrgFreedesktopUDisksProxy.
3911  * @out_devices: (out): Return location for return parameter or %NULL to ignore.
3912  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_enumerate_devices().
3913  * @error: Return location for error or %NULL.
3914  *
3915  * Finishes an operation started with org_freedesktop_udisks_call_enumerate_devices().
3916  *
3917  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
3918  */
3919 gboolean
3920 org_freedesktop_udisks_call_enumerate_devices_finish (
3921     OrgFreedesktopUDisks *proxy,
3922     gchar ***out_devices,
3923     GAsyncResult *res,
3924     GError **error)
3925 {
3926   GVariant *_ret;
3927   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
3928   if (_ret == NULL)
3929     goto _out;
3930   g_variant_get (_ret,
3931                  "(^ao)",
3932                  out_devices);
3933   g_variant_unref (_ret);
3934 _out:
3935   return _ret != NULL;
3936 }
3937
3938 /**
3939  * org_freedesktop_udisks_call_enumerate_devices_sync:
3940  * @proxy: A #OrgFreedesktopUDisksProxy.
3941  * @out_devices: (out): Return location for return parameter or %NULL to ignore.
3942  * @cancellable: (allow-none): A #GCancellable or %NULL.
3943  * @error: Return location for error or %NULL.
3944  *
3945  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateDevices">EnumerateDevices()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
3946  *
3947  * See org_freedesktop_udisks_call_enumerate_devices() for the asynchronous version of this method.
3948  *
3949  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
3950  */
3951 gboolean
3952 org_freedesktop_udisks_call_enumerate_devices_sync (
3953     OrgFreedesktopUDisks *proxy,
3954     gchar ***out_devices,
3955     GCancellable *cancellable,
3956     GError **error)
3957 {
3958   GVariant *_ret;
3959   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
3960     "EnumerateDevices",
3961     g_variant_new ("()"),
3962     G_DBUS_CALL_FLAGS_NONE,
3963     -1,
3964     cancellable,
3965     error);
3966   if (_ret == NULL)
3967     goto _out;
3968   g_variant_get (_ret,
3969                  "(^ao)",
3970                  out_devices);
3971   g_variant_unref (_ret);
3972 _out:
3973   return _ret != NULL;
3974 }
3975
3976 /**
3977  * org_freedesktop_udisks_call_enumerate_device_files:
3978  * @proxy: A #OrgFreedesktopUDisksProxy.
3979  * @cancellable: (allow-none): A #GCancellable or %NULL.
3980  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
3981  * @user_data: User data to pass to @callback.
3982  *
3983  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateDeviceFiles">EnumerateDeviceFiles()</link> D-Bus method on @proxy.
3984  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
3985  * You can then call org_freedesktop_udisks_call_enumerate_device_files_finish() to get the result of the operation.
3986  *
3987  * See org_freedesktop_udisks_call_enumerate_device_files_sync() for the synchronous, blocking version of this method.
3988  */
3989 void
3990 org_freedesktop_udisks_call_enumerate_device_files (
3991     OrgFreedesktopUDisks *proxy,
3992     GCancellable *cancellable,
3993     GAsyncReadyCallback callback,
3994     gpointer user_data)
3995 {
3996   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
3997     "EnumerateDeviceFiles",
3998     g_variant_new ("()"),
3999     G_DBUS_CALL_FLAGS_NONE,
4000     -1,
4001     cancellable,
4002     callback,
4003     user_data);
4004 }
4005
4006 /**
4007  * org_freedesktop_udisks_call_enumerate_device_files_finish:
4008  * @proxy: A #OrgFreedesktopUDisksProxy.
4009  * @out_device_files: (out): Return location for return parameter or %NULL to ignore.
4010  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_enumerate_device_files().
4011  * @error: Return location for error or %NULL.
4012  *
4013  * Finishes an operation started with org_freedesktop_udisks_call_enumerate_device_files().
4014  *
4015  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4016  */
4017 gboolean
4018 org_freedesktop_udisks_call_enumerate_device_files_finish (
4019     OrgFreedesktopUDisks *proxy,
4020     gchar ***out_device_files,
4021     GAsyncResult *res,
4022     GError **error)
4023 {
4024   GVariant *_ret;
4025   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4026   if (_ret == NULL)
4027     goto _out;
4028   g_variant_get (_ret,
4029                  "(^as)",
4030                  out_device_files);
4031   g_variant_unref (_ret);
4032 _out:
4033   return _ret != NULL;
4034 }
4035
4036 /**
4037  * org_freedesktop_udisks_call_enumerate_device_files_sync:
4038  * @proxy: A #OrgFreedesktopUDisksProxy.
4039  * @out_device_files: (out): Return location for return parameter or %NULL to ignore.
4040  * @cancellable: (allow-none): A #GCancellable or %NULL.
4041  * @error: Return location for error or %NULL.
4042  *
4043  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateDeviceFiles">EnumerateDeviceFiles()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4044  *
4045  * See org_freedesktop_udisks_call_enumerate_device_files() for the asynchronous version of this method.
4046  *
4047  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4048  */
4049 gboolean
4050 org_freedesktop_udisks_call_enumerate_device_files_sync (
4051     OrgFreedesktopUDisks *proxy,
4052     gchar ***out_device_files,
4053     GCancellable *cancellable,
4054     GError **error)
4055 {
4056   GVariant *_ret;
4057   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4058     "EnumerateDeviceFiles",
4059     g_variant_new ("()"),
4060     G_DBUS_CALL_FLAGS_NONE,
4061     -1,
4062     cancellable,
4063     error);
4064   if (_ret == NULL)
4065     goto _out;
4066   g_variant_get (_ret,
4067                  "(^as)",
4068                  out_device_files);
4069   g_variant_unref (_ret);
4070 _out:
4071   return _ret != NULL;
4072 }
4073
4074 /**
4075  * org_freedesktop_udisks_call_find_device_by_device_file:
4076  * @proxy: A #OrgFreedesktopUDisksProxy.
4077  * @arg_device_file: Argument to pass with the method invocation.
4078  * @cancellable: (allow-none): A #GCancellable or %NULL.
4079  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4080  * @user_data: User data to pass to @callback.
4081  *
4082  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.FindDeviceByDeviceFile">FindDeviceByDeviceFile()</link> D-Bus method on @proxy.
4083  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
4084  * You can then call org_freedesktop_udisks_call_find_device_by_device_file_finish() to get the result of the operation.
4085  *
4086  * See org_freedesktop_udisks_call_find_device_by_device_file_sync() for the synchronous, blocking version of this method.
4087  */
4088 void
4089 org_freedesktop_udisks_call_find_device_by_device_file (
4090     OrgFreedesktopUDisks *proxy,
4091     const gchar *arg_device_file,
4092     GCancellable *cancellable,
4093     GAsyncReadyCallback callback,
4094     gpointer user_data)
4095 {
4096   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4097     "FindDeviceByDeviceFile",
4098     g_variant_new ("(s)",
4099                    arg_device_file),
4100     G_DBUS_CALL_FLAGS_NONE,
4101     -1,
4102     cancellable,
4103     callback,
4104     user_data);
4105 }
4106
4107 /**
4108  * org_freedesktop_udisks_call_find_device_by_device_file_finish:
4109  * @proxy: A #OrgFreedesktopUDisksProxy.
4110  * @out_device: (out): Return location for return parameter or %NULL to ignore.
4111  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_find_device_by_device_file().
4112  * @error: Return location for error or %NULL.
4113  *
4114  * Finishes an operation started with org_freedesktop_udisks_call_find_device_by_device_file().
4115  *
4116  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4117  */
4118 gboolean
4119 org_freedesktop_udisks_call_find_device_by_device_file_finish (
4120     OrgFreedesktopUDisks *proxy,
4121     gchar **out_device,
4122     GAsyncResult *res,
4123     GError **error)
4124 {
4125   GVariant *_ret;
4126   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4127   if (_ret == NULL)
4128     goto _out;
4129   g_variant_get (_ret,
4130                  "(o)",
4131                  out_device);
4132   g_variant_unref (_ret);
4133 _out:
4134   return _ret != NULL;
4135 }
4136
4137 /**
4138  * org_freedesktop_udisks_call_find_device_by_device_file_sync:
4139  * @proxy: A #OrgFreedesktopUDisksProxy.
4140  * @arg_device_file: Argument to pass with the method invocation.
4141  * @out_device: (out): Return location for return parameter or %NULL to ignore.
4142  * @cancellable: (allow-none): A #GCancellable or %NULL.
4143  * @error: Return location for error or %NULL.
4144  *
4145  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.FindDeviceByDeviceFile">FindDeviceByDeviceFile()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4146  *
4147  * See org_freedesktop_udisks_call_find_device_by_device_file() for the asynchronous version of this method.
4148  *
4149  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4150  */
4151 gboolean
4152 org_freedesktop_udisks_call_find_device_by_device_file_sync (
4153     OrgFreedesktopUDisks *proxy,
4154     const gchar *arg_device_file,
4155     gchar **out_device,
4156     GCancellable *cancellable,
4157     GError **error)
4158 {
4159   GVariant *_ret;
4160   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4161     "FindDeviceByDeviceFile",
4162     g_variant_new ("(s)",
4163                    arg_device_file),
4164     G_DBUS_CALL_FLAGS_NONE,
4165     -1,
4166     cancellable,
4167     error);
4168   if (_ret == NULL)
4169     goto _out;
4170   g_variant_get (_ret,
4171                  "(o)",
4172                  out_device);
4173   g_variant_unref (_ret);
4174 _out:
4175   return _ret != NULL;
4176 }
4177
4178 /**
4179  * org_freedesktop_udisks_call_find_device_by_major_minor:
4180  * @proxy: A #OrgFreedesktopUDisksProxy.
4181  * @arg_device_major: Argument to pass with the method invocation.
4182  * @arg_device_minor: Argument to pass with the method invocation.
4183  * @cancellable: (allow-none): A #GCancellable or %NULL.
4184  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4185  * @user_data: User data to pass to @callback.
4186  *
4187  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.FindDeviceByMajorMinor">FindDeviceByMajorMinor()</link> D-Bus method on @proxy.
4188  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
4189  * You can then call org_freedesktop_udisks_call_find_device_by_major_minor_finish() to get the result of the operation.
4190  *
4191  * See org_freedesktop_udisks_call_find_device_by_major_minor_sync() for the synchronous, blocking version of this method.
4192  */
4193 void
4194 org_freedesktop_udisks_call_find_device_by_major_minor (
4195     OrgFreedesktopUDisks *proxy,
4196     gint64 arg_device_major,
4197     gint64 arg_device_minor,
4198     GCancellable *cancellable,
4199     GAsyncReadyCallback callback,
4200     gpointer user_data)
4201 {
4202   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4203     "FindDeviceByMajorMinor",
4204     g_variant_new ("(xx)",
4205                    arg_device_major,
4206                    arg_device_minor),
4207     G_DBUS_CALL_FLAGS_NONE,
4208     -1,
4209     cancellable,
4210     callback,
4211     user_data);
4212 }
4213
4214 /**
4215  * org_freedesktop_udisks_call_find_device_by_major_minor_finish:
4216  * @proxy: A #OrgFreedesktopUDisksProxy.
4217  * @out_device: (out): Return location for return parameter or %NULL to ignore.
4218  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_find_device_by_major_minor().
4219  * @error: Return location for error or %NULL.
4220  *
4221  * Finishes an operation started with org_freedesktop_udisks_call_find_device_by_major_minor().
4222  *
4223  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4224  */
4225 gboolean
4226 org_freedesktop_udisks_call_find_device_by_major_minor_finish (
4227     OrgFreedesktopUDisks *proxy,
4228     gchar **out_device,
4229     GAsyncResult *res,
4230     GError **error)
4231 {
4232   GVariant *_ret;
4233   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4234   if (_ret == NULL)
4235     goto _out;
4236   g_variant_get (_ret,
4237                  "(o)",
4238                  out_device);
4239   g_variant_unref (_ret);
4240 _out:
4241   return _ret != NULL;
4242 }
4243
4244 /**
4245  * org_freedesktop_udisks_call_find_device_by_major_minor_sync:
4246  * @proxy: A #OrgFreedesktopUDisksProxy.
4247  * @arg_device_major: Argument to pass with the method invocation.
4248  * @arg_device_minor: Argument to pass with the method invocation.
4249  * @out_device: (out): Return location for return parameter or %NULL to ignore.
4250  * @cancellable: (allow-none): A #GCancellable or %NULL.
4251  * @error: Return location for error or %NULL.
4252  *
4253  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.FindDeviceByMajorMinor">FindDeviceByMajorMinor()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4254  *
4255  * See org_freedesktop_udisks_call_find_device_by_major_minor() for the asynchronous version of this method.
4256  *
4257  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4258  */
4259 gboolean
4260 org_freedesktop_udisks_call_find_device_by_major_minor_sync (
4261     OrgFreedesktopUDisks *proxy,
4262     gint64 arg_device_major,
4263     gint64 arg_device_minor,
4264     gchar **out_device,
4265     GCancellable *cancellable,
4266     GError **error)
4267 {
4268   GVariant *_ret;
4269   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4270     "FindDeviceByMajorMinor",
4271     g_variant_new ("(xx)",
4272                    arg_device_major,
4273                    arg_device_minor),
4274     G_DBUS_CALL_FLAGS_NONE,
4275     -1,
4276     cancellable,
4277     error);
4278   if (_ret == NULL)
4279     goto _out;
4280   g_variant_get (_ret,
4281                  "(o)",
4282                  out_device);
4283   g_variant_unref (_ret);
4284 _out:
4285   return _ret != NULL;
4286 }
4287
4288 /**
4289  * org_freedesktop_udisks_call_drive_inhibit_all_polling:
4290  * @proxy: A #OrgFreedesktopUDisksProxy.
4291  * @arg_options: Argument to pass with the method invocation.
4292  * @cancellable: (allow-none): A #GCancellable or %NULL.
4293  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4294  * @user_data: User data to pass to @callback.
4295  *
4296  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveInhibitAllPolling">DriveInhibitAllPolling()</link> D-Bus method on @proxy.
4297  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
4298  * You can then call org_freedesktop_udisks_call_drive_inhibit_all_polling_finish() to get the result of the operation.
4299  *
4300  * See org_freedesktop_udisks_call_drive_inhibit_all_polling_sync() for the synchronous, blocking version of this method.
4301  */
4302 void
4303 org_freedesktop_udisks_call_drive_inhibit_all_polling (
4304     OrgFreedesktopUDisks *proxy,
4305     const gchar *const *arg_options,
4306     GCancellable *cancellable,
4307     GAsyncReadyCallback callback,
4308     gpointer user_data)
4309 {
4310   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4311     "DriveInhibitAllPolling",
4312     g_variant_new ("(^as)",
4313                    arg_options),
4314     G_DBUS_CALL_FLAGS_NONE,
4315     -1,
4316     cancellable,
4317     callback,
4318     user_data);
4319 }
4320
4321 /**
4322  * org_freedesktop_udisks_call_drive_inhibit_all_polling_finish:
4323  * @proxy: A #OrgFreedesktopUDisksProxy.
4324  * @out_cookie: (out): Return location for return parameter or %NULL to ignore.
4325  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_drive_inhibit_all_polling().
4326  * @error: Return location for error or %NULL.
4327  *
4328  * Finishes an operation started with org_freedesktop_udisks_call_drive_inhibit_all_polling().
4329  *
4330  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4331  */
4332 gboolean
4333 org_freedesktop_udisks_call_drive_inhibit_all_polling_finish (
4334     OrgFreedesktopUDisks *proxy,
4335     gchar **out_cookie,
4336     GAsyncResult *res,
4337     GError **error)
4338 {
4339   GVariant *_ret;
4340   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4341   if (_ret == NULL)
4342     goto _out;
4343   g_variant_get (_ret,
4344                  "(s)",
4345                  out_cookie);
4346   g_variant_unref (_ret);
4347 _out:
4348   return _ret != NULL;
4349 }
4350
4351 /**
4352  * org_freedesktop_udisks_call_drive_inhibit_all_polling_sync:
4353  * @proxy: A #OrgFreedesktopUDisksProxy.
4354  * @arg_options: Argument to pass with the method invocation.
4355  * @out_cookie: (out): Return location for return parameter or %NULL to ignore.
4356  * @cancellable: (allow-none): A #GCancellable or %NULL.
4357  * @error: Return location for error or %NULL.
4358  *
4359  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveInhibitAllPolling">DriveInhibitAllPolling()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4360  *
4361  * See org_freedesktop_udisks_call_drive_inhibit_all_polling() for the asynchronous version of this method.
4362  *
4363  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4364  */
4365 gboolean
4366 org_freedesktop_udisks_call_drive_inhibit_all_polling_sync (
4367     OrgFreedesktopUDisks *proxy,
4368     const gchar *const *arg_options,
4369     gchar **out_cookie,
4370     GCancellable *cancellable,
4371     GError **error)
4372 {
4373   GVariant *_ret;
4374   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4375     "DriveInhibitAllPolling",
4376     g_variant_new ("(^as)",
4377                    arg_options),
4378     G_DBUS_CALL_FLAGS_NONE,
4379     -1,
4380     cancellable,
4381     error);
4382   if (_ret == NULL)
4383     goto _out;
4384   g_variant_get (_ret,
4385                  "(s)",
4386                  out_cookie);
4387   g_variant_unref (_ret);
4388 _out:
4389   return _ret != NULL;
4390 }
4391
4392 /**
4393  * org_freedesktop_udisks_call_drive_uninhibit_all_polling:
4394  * @proxy: A #OrgFreedesktopUDisksProxy.
4395  * @arg_cookie: Argument to pass with the method invocation.
4396  * @cancellable: (allow-none): A #GCancellable or %NULL.
4397  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4398  * @user_data: User data to pass to @callback.
4399  *
4400  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveUninhibitAllPolling">DriveUninhibitAllPolling()</link> D-Bus method on @proxy.
4401  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
4402  * You can then call org_freedesktop_udisks_call_drive_uninhibit_all_polling_finish() to get the result of the operation.
4403  *
4404  * See org_freedesktop_udisks_call_drive_uninhibit_all_polling_sync() for the synchronous, blocking version of this method.
4405  */
4406 void
4407 org_freedesktop_udisks_call_drive_uninhibit_all_polling (
4408     OrgFreedesktopUDisks *proxy,
4409     const gchar *arg_cookie,
4410     GCancellable *cancellable,
4411     GAsyncReadyCallback callback,
4412     gpointer user_data)
4413 {
4414   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4415     "DriveUninhibitAllPolling",
4416     g_variant_new ("(s)",
4417                    arg_cookie),
4418     G_DBUS_CALL_FLAGS_NONE,
4419     -1,
4420     cancellable,
4421     callback,
4422     user_data);
4423 }
4424
4425 /**
4426  * org_freedesktop_udisks_call_drive_uninhibit_all_polling_finish:
4427  * @proxy: A #OrgFreedesktopUDisksProxy.
4428  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_drive_uninhibit_all_polling().
4429  * @error: Return location for error or %NULL.
4430  *
4431  * Finishes an operation started with org_freedesktop_udisks_call_drive_uninhibit_all_polling().
4432  *
4433  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4434  */
4435 gboolean
4436 org_freedesktop_udisks_call_drive_uninhibit_all_polling_finish (
4437     OrgFreedesktopUDisks *proxy,
4438     GAsyncResult *res,
4439     GError **error)
4440 {
4441   GVariant *_ret;
4442   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4443   if (_ret == NULL)
4444     goto _out;
4445   g_variant_get (_ret,
4446                  "()");
4447   g_variant_unref (_ret);
4448 _out:
4449   return _ret != NULL;
4450 }
4451
4452 /**
4453  * org_freedesktop_udisks_call_drive_uninhibit_all_polling_sync:
4454  * @proxy: A #OrgFreedesktopUDisksProxy.
4455  * @arg_cookie: Argument to pass with the method invocation.
4456  * @cancellable: (allow-none): A #GCancellable or %NULL.
4457  * @error: Return location for error or %NULL.
4458  *
4459  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveUninhibitAllPolling">DriveUninhibitAllPolling()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4460  *
4461  * See org_freedesktop_udisks_call_drive_uninhibit_all_polling() for the asynchronous version of this method.
4462  *
4463  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4464  */
4465 gboolean
4466 org_freedesktop_udisks_call_drive_uninhibit_all_polling_sync (
4467     OrgFreedesktopUDisks *proxy,
4468     const gchar *arg_cookie,
4469     GCancellable *cancellable,
4470     GError **error)
4471 {
4472   GVariant *_ret;
4473   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4474     "DriveUninhibitAllPolling",
4475     g_variant_new ("(s)",
4476                    arg_cookie),
4477     G_DBUS_CALL_FLAGS_NONE,
4478     -1,
4479     cancellable,
4480     error);
4481   if (_ret == NULL)
4482     goto _out;
4483   g_variant_get (_ret,
4484                  "()");
4485   g_variant_unref (_ret);
4486 _out:
4487   return _ret != NULL;
4488 }
4489
4490 /**
4491  * org_freedesktop_udisks_call_drive_set_all_spindown_timeouts:
4492  * @proxy: A #OrgFreedesktopUDisksProxy.
4493  * @arg_timeout_seconds: Argument to pass with the method invocation.
4494  * @arg_options: Argument to pass with the method invocation.
4495  * @cancellable: (allow-none): A #GCancellable or %NULL.
4496  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4497  * @user_data: User data to pass to @callback.
4498  *
4499  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveSetAllSpindownTimeouts">DriveSetAllSpindownTimeouts()</link> D-Bus method on @proxy.
4500  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
4501  * You can then call org_freedesktop_udisks_call_drive_set_all_spindown_timeouts_finish() to get the result of the operation.
4502  *
4503  * See org_freedesktop_udisks_call_drive_set_all_spindown_timeouts_sync() for the synchronous, blocking version of this method.
4504  */
4505 void
4506 org_freedesktop_udisks_call_drive_set_all_spindown_timeouts (
4507     OrgFreedesktopUDisks *proxy,
4508     gint arg_timeout_seconds,
4509     const gchar *const *arg_options,
4510     GCancellable *cancellable,
4511     GAsyncReadyCallback callback,
4512     gpointer user_data)
4513 {
4514   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4515     "DriveSetAllSpindownTimeouts",
4516     g_variant_new ("(i^as)",
4517                    arg_timeout_seconds,
4518                    arg_options),
4519     G_DBUS_CALL_FLAGS_NONE,
4520     -1,
4521     cancellable,
4522     callback,
4523     user_data);
4524 }
4525
4526 /**
4527  * org_freedesktop_udisks_call_drive_set_all_spindown_timeouts_finish:
4528  * @proxy: A #OrgFreedesktopUDisksProxy.
4529  * @out_cookie: (out): Return location for return parameter or %NULL to ignore.
4530  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_drive_set_all_spindown_timeouts().
4531  * @error: Return location for error or %NULL.
4532  *
4533  * Finishes an operation started with org_freedesktop_udisks_call_drive_set_all_spindown_timeouts().
4534  *
4535  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4536  */
4537 gboolean
4538 org_freedesktop_udisks_call_drive_set_all_spindown_timeouts_finish (
4539     OrgFreedesktopUDisks *proxy,
4540     gchar **out_cookie,
4541     GAsyncResult *res,
4542     GError **error)
4543 {
4544   GVariant *_ret;
4545   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4546   if (_ret == NULL)
4547     goto _out;
4548   g_variant_get (_ret,
4549                  "(s)",
4550                  out_cookie);
4551   g_variant_unref (_ret);
4552 _out:
4553   return _ret != NULL;
4554 }
4555
4556 /**
4557  * org_freedesktop_udisks_call_drive_set_all_spindown_timeouts_sync:
4558  * @proxy: A #OrgFreedesktopUDisksProxy.
4559  * @arg_timeout_seconds: Argument to pass with the method invocation.
4560  * @arg_options: Argument to pass with the method invocation.
4561  * @out_cookie: (out): Return location for return parameter or %NULL to ignore.
4562  * @cancellable: (allow-none): A #GCancellable or %NULL.
4563  * @error: Return location for error or %NULL.
4564  *
4565  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveSetAllSpindownTimeouts">DriveSetAllSpindownTimeouts()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4566  *
4567  * See org_freedesktop_udisks_call_drive_set_all_spindown_timeouts() for the asynchronous version of this method.
4568  *
4569  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4570  */
4571 gboolean
4572 org_freedesktop_udisks_call_drive_set_all_spindown_timeouts_sync (
4573     OrgFreedesktopUDisks *proxy,
4574     gint arg_timeout_seconds,
4575     const gchar *const *arg_options,
4576     gchar **out_cookie,
4577     GCancellable *cancellable,
4578     GError **error)
4579 {
4580   GVariant *_ret;
4581   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4582     "DriveSetAllSpindownTimeouts",
4583     g_variant_new ("(i^as)",
4584                    arg_timeout_seconds,
4585                    arg_options),
4586     G_DBUS_CALL_FLAGS_NONE,
4587     -1,
4588     cancellable,
4589     error);
4590   if (_ret == NULL)
4591     goto _out;
4592   g_variant_get (_ret,
4593                  "(s)",
4594                  out_cookie);
4595   g_variant_unref (_ret);
4596 _out:
4597   return _ret != NULL;
4598 }
4599
4600 /**
4601  * org_freedesktop_udisks_call_drive_unset_all_spindown_timeouts:
4602  * @proxy: A #OrgFreedesktopUDisksProxy.
4603  * @arg_cookie: Argument to pass with the method invocation.
4604  * @cancellable: (allow-none): A #GCancellable or %NULL.
4605  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4606  * @user_data: User data to pass to @callback.
4607  *
4608  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveUnsetAllSpindownTimeouts">DriveUnsetAllSpindownTimeouts()</link> D-Bus method on @proxy.
4609  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
4610  * You can then call org_freedesktop_udisks_call_drive_unset_all_spindown_timeouts_finish() to get the result of the operation.
4611  *
4612  * See org_freedesktop_udisks_call_drive_unset_all_spindown_timeouts_sync() for the synchronous, blocking version of this method.
4613  */
4614 void
4615 org_freedesktop_udisks_call_drive_unset_all_spindown_timeouts (
4616     OrgFreedesktopUDisks *proxy,
4617     const gchar *arg_cookie,
4618     GCancellable *cancellable,
4619     GAsyncReadyCallback callback,
4620     gpointer user_data)
4621 {
4622   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4623     "DriveUnsetAllSpindownTimeouts",
4624     g_variant_new ("(s)",
4625                    arg_cookie),
4626     G_DBUS_CALL_FLAGS_NONE,
4627     -1,
4628     cancellable,
4629     callback,
4630     user_data);
4631 }
4632
4633 /**
4634  * org_freedesktop_udisks_call_drive_unset_all_spindown_timeouts_finish:
4635  * @proxy: A #OrgFreedesktopUDisksProxy.
4636  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_drive_unset_all_spindown_timeouts().
4637  * @error: Return location for error or %NULL.
4638  *
4639  * Finishes an operation started with org_freedesktop_udisks_call_drive_unset_all_spindown_timeouts().
4640  *
4641  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4642  */
4643 gboolean
4644 org_freedesktop_udisks_call_drive_unset_all_spindown_timeouts_finish (
4645     OrgFreedesktopUDisks *proxy,
4646     GAsyncResult *res,
4647     GError **error)
4648 {
4649   GVariant *_ret;
4650   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4651   if (_ret == NULL)
4652     goto _out;
4653   g_variant_get (_ret,
4654                  "()");
4655   g_variant_unref (_ret);
4656 _out:
4657   return _ret != NULL;
4658 }
4659
4660 /**
4661  * org_freedesktop_udisks_call_drive_unset_all_spindown_timeouts_sync:
4662  * @proxy: A #OrgFreedesktopUDisksProxy.
4663  * @arg_cookie: Argument to pass with the method invocation.
4664  * @cancellable: (allow-none): A #GCancellable or %NULL.
4665  * @error: Return location for error or %NULL.
4666  *
4667  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveUnsetAllSpindownTimeouts">DriveUnsetAllSpindownTimeouts()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4668  *
4669  * See org_freedesktop_udisks_call_drive_unset_all_spindown_timeouts() for the asynchronous version of this method.
4670  *
4671  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4672  */
4673 gboolean
4674 org_freedesktop_udisks_call_drive_unset_all_spindown_timeouts_sync (
4675     OrgFreedesktopUDisks *proxy,
4676     const gchar *arg_cookie,
4677     GCancellable *cancellable,
4678     GError **error)
4679 {
4680   GVariant *_ret;
4681   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4682     "DriveUnsetAllSpindownTimeouts",
4683     g_variant_new ("(s)",
4684                    arg_cookie),
4685     G_DBUS_CALL_FLAGS_NONE,
4686     -1,
4687     cancellable,
4688     error);
4689   if (_ret == NULL)
4690     goto _out;
4691   g_variant_get (_ret,
4692                  "()");
4693   g_variant_unref (_ret);
4694 _out:
4695   return _ret != NULL;
4696 }
4697
4698 /**
4699  * org_freedesktop_udisks_call_linux_lvm2_vgstart:
4700  * @proxy: A #OrgFreedesktopUDisksProxy.
4701  * @arg_uuid: Argument to pass with the method invocation.
4702  * @arg_options: Argument to pass with the method invocation.
4703  * @cancellable: (allow-none): A #GCancellable or %NULL.
4704  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4705  * @user_data: User data to pass to @callback.
4706  *
4707  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGStart">LinuxLvm2VGStart()</link> D-Bus method on @proxy.
4708  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
4709  * You can then call org_freedesktop_udisks_call_linux_lvm2_vgstart_finish() to get the result of the operation.
4710  *
4711  * See org_freedesktop_udisks_call_linux_lvm2_vgstart_sync() for the synchronous, blocking version of this method.
4712  */
4713 void
4714 org_freedesktop_udisks_call_linux_lvm2_vgstart (
4715     OrgFreedesktopUDisks *proxy,
4716     const gchar *arg_uuid,
4717     const gchar *const *arg_options,
4718     GCancellable *cancellable,
4719     GAsyncReadyCallback callback,
4720     gpointer user_data)
4721 {
4722   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4723     "LinuxLvm2VGStart",
4724     g_variant_new ("(s^as)",
4725                    arg_uuid,
4726                    arg_options),
4727     G_DBUS_CALL_FLAGS_NONE,
4728     -1,
4729     cancellable,
4730     callback,
4731     user_data);
4732 }
4733
4734 /**
4735  * org_freedesktop_udisks_call_linux_lvm2_vgstart_finish:
4736  * @proxy: A #OrgFreedesktopUDisksProxy.
4737  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_linux_lvm2_vgstart().
4738  * @error: Return location for error or %NULL.
4739  *
4740  * Finishes an operation started with org_freedesktop_udisks_call_linux_lvm2_vgstart().
4741  *
4742  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4743  */
4744 gboolean
4745 org_freedesktop_udisks_call_linux_lvm2_vgstart_finish (
4746     OrgFreedesktopUDisks *proxy,
4747     GAsyncResult *res,
4748     GError **error)
4749 {
4750   GVariant *_ret;
4751   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4752   if (_ret == NULL)
4753     goto _out;
4754   g_variant_get (_ret,
4755                  "()");
4756   g_variant_unref (_ret);
4757 _out:
4758   return _ret != NULL;
4759 }
4760
4761 /**
4762  * org_freedesktop_udisks_call_linux_lvm2_vgstart_sync:
4763  * @proxy: A #OrgFreedesktopUDisksProxy.
4764  * @arg_uuid: Argument to pass with the method invocation.
4765  * @arg_options: Argument to pass with the method invocation.
4766  * @cancellable: (allow-none): A #GCancellable or %NULL.
4767  * @error: Return location for error or %NULL.
4768  *
4769  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGStart">LinuxLvm2VGStart()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4770  *
4771  * See org_freedesktop_udisks_call_linux_lvm2_vgstart() for the asynchronous version of this method.
4772  *
4773  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4774  */
4775 gboolean
4776 org_freedesktop_udisks_call_linux_lvm2_vgstart_sync (
4777     OrgFreedesktopUDisks *proxy,
4778     const gchar *arg_uuid,
4779     const gchar *const *arg_options,
4780     GCancellable *cancellable,
4781     GError **error)
4782 {
4783   GVariant *_ret;
4784   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4785     "LinuxLvm2VGStart",
4786     g_variant_new ("(s^as)",
4787                    arg_uuid,
4788                    arg_options),
4789     G_DBUS_CALL_FLAGS_NONE,
4790     -1,
4791     cancellable,
4792     error);
4793   if (_ret == NULL)
4794     goto _out;
4795   g_variant_get (_ret,
4796                  "()");
4797   g_variant_unref (_ret);
4798 _out:
4799   return _ret != NULL;
4800 }
4801
4802 /**
4803  * org_freedesktop_udisks_call_linux_lvm2_vgstop:
4804  * @proxy: A #OrgFreedesktopUDisksProxy.
4805  * @arg_uuid: Argument to pass with the method invocation.
4806  * @arg_options: Argument to pass with the method invocation.
4807  * @cancellable: (allow-none): A #GCancellable or %NULL.
4808  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4809  * @user_data: User data to pass to @callback.
4810  *
4811  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGStop">LinuxLvm2VGStop()</link> D-Bus method on @proxy.
4812  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
4813  * You can then call org_freedesktop_udisks_call_linux_lvm2_vgstop_finish() to get the result of the operation.
4814  *
4815  * See org_freedesktop_udisks_call_linux_lvm2_vgstop_sync() for the synchronous, blocking version of this method.
4816  */
4817 void
4818 org_freedesktop_udisks_call_linux_lvm2_vgstop (
4819     OrgFreedesktopUDisks *proxy,
4820     const gchar *arg_uuid,
4821     const gchar *const *arg_options,
4822     GCancellable *cancellable,
4823     GAsyncReadyCallback callback,
4824     gpointer user_data)
4825 {
4826   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4827     "LinuxLvm2VGStop",
4828     g_variant_new ("(s^as)",
4829                    arg_uuid,
4830                    arg_options),
4831     G_DBUS_CALL_FLAGS_NONE,
4832     -1,
4833     cancellable,
4834     callback,
4835     user_data);
4836 }
4837
4838 /**
4839  * org_freedesktop_udisks_call_linux_lvm2_vgstop_finish:
4840  * @proxy: A #OrgFreedesktopUDisksProxy.
4841  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_linux_lvm2_vgstop().
4842  * @error: Return location for error or %NULL.
4843  *
4844  * Finishes an operation started with org_freedesktop_udisks_call_linux_lvm2_vgstop().
4845  *
4846  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4847  */
4848 gboolean
4849 org_freedesktop_udisks_call_linux_lvm2_vgstop_finish (
4850     OrgFreedesktopUDisks *proxy,
4851     GAsyncResult *res,
4852     GError **error)
4853 {
4854   GVariant *_ret;
4855   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4856   if (_ret == NULL)
4857     goto _out;
4858   g_variant_get (_ret,
4859                  "()");
4860   g_variant_unref (_ret);
4861 _out:
4862   return _ret != NULL;
4863 }
4864
4865 /**
4866  * org_freedesktop_udisks_call_linux_lvm2_vgstop_sync:
4867  * @proxy: A #OrgFreedesktopUDisksProxy.
4868  * @arg_uuid: Argument to pass with the method invocation.
4869  * @arg_options: Argument to pass with the method invocation.
4870  * @cancellable: (allow-none): A #GCancellable or %NULL.
4871  * @error: Return location for error or %NULL.
4872  *
4873  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGStop">LinuxLvm2VGStop()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4874  *
4875  * See org_freedesktop_udisks_call_linux_lvm2_vgstop() for the asynchronous version of this method.
4876  *
4877  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4878  */
4879 gboolean
4880 org_freedesktop_udisks_call_linux_lvm2_vgstop_sync (
4881     OrgFreedesktopUDisks *proxy,
4882     const gchar *arg_uuid,
4883     const gchar *const *arg_options,
4884     GCancellable *cancellable,
4885     GError **error)
4886 {
4887   GVariant *_ret;
4888   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4889     "LinuxLvm2VGStop",
4890     g_variant_new ("(s^as)",
4891                    arg_uuid,
4892                    arg_options),
4893     G_DBUS_CALL_FLAGS_NONE,
4894     -1,
4895     cancellable,
4896     error);
4897   if (_ret == NULL)
4898     goto _out;
4899   g_variant_get (_ret,
4900                  "()");
4901   g_variant_unref (_ret);
4902 _out:
4903   return _ret != NULL;
4904 }
4905
4906 /**
4907  * org_freedesktop_udisks_call_linux_lvm2_vgset_name:
4908  * @proxy: A #OrgFreedesktopUDisksProxy.
4909  * @arg_uuid: Argument to pass with the method invocation.
4910  * @arg_name: Argument to pass with the method invocation.
4911  * @cancellable: (allow-none): A #GCancellable or %NULL.
4912  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
4913  * @user_data: User data to pass to @callback.
4914  *
4915  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGSetName">LinuxLvm2VGSetName()</link> D-Bus method on @proxy.
4916  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
4917  * You can then call org_freedesktop_udisks_call_linux_lvm2_vgset_name_finish() to get the result of the operation.
4918  *
4919  * See org_freedesktop_udisks_call_linux_lvm2_vgset_name_sync() for the synchronous, blocking version of this method.
4920  */
4921 void
4922 org_freedesktop_udisks_call_linux_lvm2_vgset_name (
4923     OrgFreedesktopUDisks *proxy,
4924     const gchar *arg_uuid,
4925     const gchar *arg_name,
4926     GCancellable *cancellable,
4927     GAsyncReadyCallback callback,
4928     gpointer user_data)
4929 {
4930   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
4931     "LinuxLvm2VGSetName",
4932     g_variant_new ("(ss)",
4933                    arg_uuid,
4934                    arg_name),
4935     G_DBUS_CALL_FLAGS_NONE,
4936     -1,
4937     cancellable,
4938     callback,
4939     user_data);
4940 }
4941
4942 /**
4943  * org_freedesktop_udisks_call_linux_lvm2_vgset_name_finish:
4944  * @proxy: A #OrgFreedesktopUDisksProxy.
4945  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_linux_lvm2_vgset_name().
4946  * @error: Return location for error or %NULL.
4947  *
4948  * Finishes an operation started with org_freedesktop_udisks_call_linux_lvm2_vgset_name().
4949  *
4950  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4951  */
4952 gboolean
4953 org_freedesktop_udisks_call_linux_lvm2_vgset_name_finish (
4954     OrgFreedesktopUDisks *proxy,
4955     GAsyncResult *res,
4956     GError **error)
4957 {
4958   GVariant *_ret;
4959   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
4960   if (_ret == NULL)
4961     goto _out;
4962   g_variant_get (_ret,
4963                  "()");
4964   g_variant_unref (_ret);
4965 _out:
4966   return _ret != NULL;
4967 }
4968
4969 /**
4970  * org_freedesktop_udisks_call_linux_lvm2_vgset_name_sync:
4971  * @proxy: A #OrgFreedesktopUDisksProxy.
4972  * @arg_uuid: Argument to pass with the method invocation.
4973  * @arg_name: Argument to pass with the method invocation.
4974  * @cancellable: (allow-none): A #GCancellable or %NULL.
4975  * @error: Return location for error or %NULL.
4976  *
4977  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGSetName">LinuxLvm2VGSetName()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
4978  *
4979  * See org_freedesktop_udisks_call_linux_lvm2_vgset_name() for the asynchronous version of this method.
4980  *
4981  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
4982  */
4983 gboolean
4984 org_freedesktop_udisks_call_linux_lvm2_vgset_name_sync (
4985     OrgFreedesktopUDisks *proxy,
4986     const gchar *arg_uuid,
4987     const gchar *arg_name,
4988     GCancellable *cancellable,
4989     GError **error)
4990 {
4991   GVariant *_ret;
4992   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
4993     "LinuxLvm2VGSetName",
4994     g_variant_new ("(ss)",
4995                    arg_uuid,
4996                    arg_name),
4997     G_DBUS_CALL_FLAGS_NONE,
4998     -1,
4999     cancellable,
5000     error);
5001   if (_ret == NULL)
5002     goto _out;
5003   g_variant_get (_ret,
5004                  "()");
5005   g_variant_unref (_ret);
5006 _out:
5007   return _ret != NULL;
5008 }
5009
5010 /**
5011  * org_freedesktop_udisks_call_linux_lvm2_vgadd_pv:
5012  * @proxy: A #OrgFreedesktopUDisksProxy.
5013  * @arg_uuid: Argument to pass with the method invocation.
5014  * @arg_physical_volume: Argument to pass with the method invocation.
5015  * @arg_options: Argument to pass with the method invocation.
5016  * @cancellable: (allow-none): A #GCancellable or %NULL.
5017  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5018  * @user_data: User data to pass to @callback.
5019  *
5020  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGAddPV">LinuxLvm2VGAddPV()</link> D-Bus method on @proxy.
5021  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
5022  * You can then call org_freedesktop_udisks_call_linux_lvm2_vgadd_pv_finish() to get the result of the operation.
5023  *
5024  * See org_freedesktop_udisks_call_linux_lvm2_vgadd_pv_sync() for the synchronous, blocking version of this method.
5025  */
5026 void
5027 org_freedesktop_udisks_call_linux_lvm2_vgadd_pv (
5028     OrgFreedesktopUDisks *proxy,
5029     const gchar *arg_uuid,
5030     const gchar *arg_physical_volume,
5031     const gchar *const *arg_options,
5032     GCancellable *cancellable,
5033     GAsyncReadyCallback callback,
5034     gpointer user_data)
5035 {
5036   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5037     "LinuxLvm2VGAddPV",
5038     g_variant_new ("(so^as)",
5039                    arg_uuid,
5040                    arg_physical_volume,
5041                    arg_options),
5042     G_DBUS_CALL_FLAGS_NONE,
5043     -1,
5044     cancellable,
5045     callback,
5046     user_data);
5047 }
5048
5049 /**
5050  * org_freedesktop_udisks_call_linux_lvm2_vgadd_pv_finish:
5051  * @proxy: A #OrgFreedesktopUDisksProxy.
5052  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_linux_lvm2_vgadd_pv().
5053  * @error: Return location for error or %NULL.
5054  *
5055  * Finishes an operation started with org_freedesktop_udisks_call_linux_lvm2_vgadd_pv().
5056  *
5057  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5058  */
5059 gboolean
5060 org_freedesktop_udisks_call_linux_lvm2_vgadd_pv_finish (
5061     OrgFreedesktopUDisks *proxy,
5062     GAsyncResult *res,
5063     GError **error)
5064 {
5065   GVariant *_ret;
5066   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5067   if (_ret == NULL)
5068     goto _out;
5069   g_variant_get (_ret,
5070                  "()");
5071   g_variant_unref (_ret);
5072 _out:
5073   return _ret != NULL;
5074 }
5075
5076 /**
5077  * org_freedesktop_udisks_call_linux_lvm2_vgadd_pv_sync:
5078  * @proxy: A #OrgFreedesktopUDisksProxy.
5079  * @arg_uuid: Argument to pass with the method invocation.
5080  * @arg_physical_volume: Argument to pass with the method invocation.
5081  * @arg_options: Argument to pass with the method invocation.
5082  * @cancellable: (allow-none): A #GCancellable or %NULL.
5083  * @error: Return location for error or %NULL.
5084  *
5085  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGAddPV">LinuxLvm2VGAddPV()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5086  *
5087  * See org_freedesktop_udisks_call_linux_lvm2_vgadd_pv() for the asynchronous version of this method.
5088  *
5089  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5090  */
5091 gboolean
5092 org_freedesktop_udisks_call_linux_lvm2_vgadd_pv_sync (
5093     OrgFreedesktopUDisks *proxy,
5094     const gchar *arg_uuid,
5095     const gchar *arg_physical_volume,
5096     const gchar *const *arg_options,
5097     GCancellable *cancellable,
5098     GError **error)
5099 {
5100   GVariant *_ret;
5101   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5102     "LinuxLvm2VGAddPV",
5103     g_variant_new ("(so^as)",
5104                    arg_uuid,
5105                    arg_physical_volume,
5106                    arg_options),
5107     G_DBUS_CALL_FLAGS_NONE,
5108     -1,
5109     cancellable,
5110     error);
5111   if (_ret == NULL)
5112     goto _out;
5113   g_variant_get (_ret,
5114                  "()");
5115   g_variant_unref (_ret);
5116 _out:
5117   return _ret != NULL;
5118 }
5119
5120 /**
5121  * org_freedesktop_udisks_call_linux_lvm2_vgremove_pv:
5122  * @proxy: A #OrgFreedesktopUDisksProxy.
5123  * @arg_vg_uuid: Argument to pass with the method invocation.
5124  * @arg_pv_uuid: Argument to pass with the method invocation.
5125  * @arg_options: Argument to pass with the method invocation.
5126  * @cancellable: (allow-none): A #GCancellable or %NULL.
5127  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5128  * @user_data: User data to pass to @callback.
5129  *
5130  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGRemovePV">LinuxLvm2VGRemovePV()</link> D-Bus method on @proxy.
5131  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
5132  * You can then call org_freedesktop_udisks_call_linux_lvm2_vgremove_pv_finish() to get the result of the operation.
5133  *
5134  * See org_freedesktop_udisks_call_linux_lvm2_vgremove_pv_sync() for the synchronous, blocking version of this method.
5135  */
5136 void
5137 org_freedesktop_udisks_call_linux_lvm2_vgremove_pv (
5138     OrgFreedesktopUDisks *proxy,
5139     const gchar *arg_vg_uuid,
5140     const gchar *arg_pv_uuid,
5141     const gchar *const *arg_options,
5142     GCancellable *cancellable,
5143     GAsyncReadyCallback callback,
5144     gpointer user_data)
5145 {
5146   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5147     "LinuxLvm2VGRemovePV",
5148     g_variant_new ("(ss^as)",
5149                    arg_vg_uuid,
5150                    arg_pv_uuid,
5151                    arg_options),
5152     G_DBUS_CALL_FLAGS_NONE,
5153     -1,
5154     cancellable,
5155     callback,
5156     user_data);
5157 }
5158
5159 /**
5160  * org_freedesktop_udisks_call_linux_lvm2_vgremove_pv_finish:
5161  * @proxy: A #OrgFreedesktopUDisksProxy.
5162  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_linux_lvm2_vgremove_pv().
5163  * @error: Return location for error or %NULL.
5164  *
5165  * Finishes an operation started with org_freedesktop_udisks_call_linux_lvm2_vgremove_pv().
5166  *
5167  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5168  */
5169 gboolean
5170 org_freedesktop_udisks_call_linux_lvm2_vgremove_pv_finish (
5171     OrgFreedesktopUDisks *proxy,
5172     GAsyncResult *res,
5173     GError **error)
5174 {
5175   GVariant *_ret;
5176   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5177   if (_ret == NULL)
5178     goto _out;
5179   g_variant_get (_ret,
5180                  "()");
5181   g_variant_unref (_ret);
5182 _out:
5183   return _ret != NULL;
5184 }
5185
5186 /**
5187  * org_freedesktop_udisks_call_linux_lvm2_vgremove_pv_sync:
5188  * @proxy: A #OrgFreedesktopUDisksProxy.
5189  * @arg_vg_uuid: Argument to pass with the method invocation.
5190  * @arg_pv_uuid: Argument to pass with the method invocation.
5191  * @arg_options: Argument to pass with the method invocation.
5192  * @cancellable: (allow-none): A #GCancellable or %NULL.
5193  * @error: Return location for error or %NULL.
5194  *
5195  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGRemovePV">LinuxLvm2VGRemovePV()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5196  *
5197  * See org_freedesktop_udisks_call_linux_lvm2_vgremove_pv() for the asynchronous version of this method.
5198  *
5199  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5200  */
5201 gboolean
5202 org_freedesktop_udisks_call_linux_lvm2_vgremove_pv_sync (
5203     OrgFreedesktopUDisks *proxy,
5204     const gchar *arg_vg_uuid,
5205     const gchar *arg_pv_uuid,
5206     const gchar *const *arg_options,
5207     GCancellable *cancellable,
5208     GError **error)
5209 {
5210   GVariant *_ret;
5211   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5212     "LinuxLvm2VGRemovePV",
5213     g_variant_new ("(ss^as)",
5214                    arg_vg_uuid,
5215                    arg_pv_uuid,
5216                    arg_options),
5217     G_DBUS_CALL_FLAGS_NONE,
5218     -1,
5219     cancellable,
5220     error);
5221   if (_ret == NULL)
5222     goto _out;
5223   g_variant_get (_ret,
5224                  "()");
5225   g_variant_unref (_ret);
5226 _out:
5227   return _ret != NULL;
5228 }
5229
5230 /**
5231  * org_freedesktop_udisks_call_linux_lvm2_lvset_name:
5232  * @proxy: A #OrgFreedesktopUDisksProxy.
5233  * @arg_group_uuid: Argument to pass with the method invocation.
5234  * @arg_uuid: Argument to pass with the method invocation.
5235  * @arg_name: Argument to pass with the method invocation.
5236  * @cancellable: (allow-none): A #GCancellable or %NULL.
5237  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5238  * @user_data: User data to pass to @callback.
5239  *
5240  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVSetName">LinuxLvm2LVSetName()</link> D-Bus method on @proxy.
5241  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
5242  * You can then call org_freedesktop_udisks_call_linux_lvm2_lvset_name_finish() to get the result of the operation.
5243  *
5244  * See org_freedesktop_udisks_call_linux_lvm2_lvset_name_sync() for the synchronous, blocking version of this method.
5245  */
5246 void
5247 org_freedesktop_udisks_call_linux_lvm2_lvset_name (
5248     OrgFreedesktopUDisks *proxy,
5249     const gchar *arg_group_uuid,
5250     const gchar *arg_uuid,
5251     const gchar *arg_name,
5252     GCancellable *cancellable,
5253     GAsyncReadyCallback callback,
5254     gpointer user_data)
5255 {
5256   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5257     "LinuxLvm2LVSetName",
5258     g_variant_new ("(sss)",
5259                    arg_group_uuid,
5260                    arg_uuid,
5261                    arg_name),
5262     G_DBUS_CALL_FLAGS_NONE,
5263     -1,
5264     cancellable,
5265     callback,
5266     user_data);
5267 }
5268
5269 /**
5270  * org_freedesktop_udisks_call_linux_lvm2_lvset_name_finish:
5271  * @proxy: A #OrgFreedesktopUDisksProxy.
5272  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_linux_lvm2_lvset_name().
5273  * @error: Return location for error or %NULL.
5274  *
5275  * Finishes an operation started with org_freedesktop_udisks_call_linux_lvm2_lvset_name().
5276  *
5277  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5278  */
5279 gboolean
5280 org_freedesktop_udisks_call_linux_lvm2_lvset_name_finish (
5281     OrgFreedesktopUDisks *proxy,
5282     GAsyncResult *res,
5283     GError **error)
5284 {
5285   GVariant *_ret;
5286   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5287   if (_ret == NULL)
5288     goto _out;
5289   g_variant_get (_ret,
5290                  "()");
5291   g_variant_unref (_ret);
5292 _out:
5293   return _ret != NULL;
5294 }
5295
5296 /**
5297  * org_freedesktop_udisks_call_linux_lvm2_lvset_name_sync:
5298  * @proxy: A #OrgFreedesktopUDisksProxy.
5299  * @arg_group_uuid: Argument to pass with the method invocation.
5300  * @arg_uuid: Argument to pass with the method invocation.
5301  * @arg_name: Argument to pass with the method invocation.
5302  * @cancellable: (allow-none): A #GCancellable or %NULL.
5303  * @error: Return location for error or %NULL.
5304  *
5305  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVSetName">LinuxLvm2LVSetName()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5306  *
5307  * See org_freedesktop_udisks_call_linux_lvm2_lvset_name() for the asynchronous version of this method.
5308  *
5309  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5310  */
5311 gboolean
5312 org_freedesktop_udisks_call_linux_lvm2_lvset_name_sync (
5313     OrgFreedesktopUDisks *proxy,
5314     const gchar *arg_group_uuid,
5315     const gchar *arg_uuid,
5316     const gchar *arg_name,
5317     GCancellable *cancellable,
5318     GError **error)
5319 {
5320   GVariant *_ret;
5321   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5322     "LinuxLvm2LVSetName",
5323     g_variant_new ("(sss)",
5324                    arg_group_uuid,
5325                    arg_uuid,
5326                    arg_name),
5327     G_DBUS_CALL_FLAGS_NONE,
5328     -1,
5329     cancellable,
5330     error);
5331   if (_ret == NULL)
5332     goto _out;
5333   g_variant_get (_ret,
5334                  "()");
5335   g_variant_unref (_ret);
5336 _out:
5337   return _ret != NULL;
5338 }
5339
5340 /**
5341  * org_freedesktop_udisks_call_linux_lvm2_lvstart:
5342  * @proxy: A #OrgFreedesktopUDisksProxy.
5343  * @arg_group_uuid: Argument to pass with the method invocation.
5344  * @arg_uuid: Argument to pass with the method invocation.
5345  * @arg_options: Argument to pass with the method invocation.
5346  * @cancellable: (allow-none): A #GCancellable or %NULL.
5347  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5348  * @user_data: User data to pass to @callback.
5349  *
5350  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVStart">LinuxLvm2LVStart()</link> D-Bus method on @proxy.
5351  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
5352  * You can then call org_freedesktop_udisks_call_linux_lvm2_lvstart_finish() to get the result of the operation.
5353  *
5354  * See org_freedesktop_udisks_call_linux_lvm2_lvstart_sync() for the synchronous, blocking version of this method.
5355  */
5356 void
5357 org_freedesktop_udisks_call_linux_lvm2_lvstart (
5358     OrgFreedesktopUDisks *proxy,
5359     const gchar *arg_group_uuid,
5360     const gchar *arg_uuid,
5361     const gchar *const *arg_options,
5362     GCancellable *cancellable,
5363     GAsyncReadyCallback callback,
5364     gpointer user_data)
5365 {
5366   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5367     "LinuxLvm2LVStart",
5368     g_variant_new ("(ss^as)",
5369                    arg_group_uuid,
5370                    arg_uuid,
5371                    arg_options),
5372     G_DBUS_CALL_FLAGS_NONE,
5373     -1,
5374     cancellable,
5375     callback,
5376     user_data);
5377 }
5378
5379 /**
5380  * org_freedesktop_udisks_call_linux_lvm2_lvstart_finish:
5381  * @proxy: A #OrgFreedesktopUDisksProxy.
5382  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_linux_lvm2_lvstart().
5383  * @error: Return location for error or %NULL.
5384  *
5385  * Finishes an operation started with org_freedesktop_udisks_call_linux_lvm2_lvstart().
5386  *
5387  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5388  */
5389 gboolean
5390 org_freedesktop_udisks_call_linux_lvm2_lvstart_finish (
5391     OrgFreedesktopUDisks *proxy,
5392     GAsyncResult *res,
5393     GError **error)
5394 {
5395   GVariant *_ret;
5396   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5397   if (_ret == NULL)
5398     goto _out;
5399   g_variant_get (_ret,
5400                  "()");
5401   g_variant_unref (_ret);
5402 _out:
5403   return _ret != NULL;
5404 }
5405
5406 /**
5407  * org_freedesktop_udisks_call_linux_lvm2_lvstart_sync:
5408  * @proxy: A #OrgFreedesktopUDisksProxy.
5409  * @arg_group_uuid: Argument to pass with the method invocation.
5410  * @arg_uuid: Argument to pass with the method invocation.
5411  * @arg_options: Argument to pass with the method invocation.
5412  * @cancellable: (allow-none): A #GCancellable or %NULL.
5413  * @error: Return location for error or %NULL.
5414  *
5415  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVStart">LinuxLvm2LVStart()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5416  *
5417  * See org_freedesktop_udisks_call_linux_lvm2_lvstart() for the asynchronous version of this method.
5418  *
5419  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5420  */
5421 gboolean
5422 org_freedesktop_udisks_call_linux_lvm2_lvstart_sync (
5423     OrgFreedesktopUDisks *proxy,
5424     const gchar *arg_group_uuid,
5425     const gchar *arg_uuid,
5426     const gchar *const *arg_options,
5427     GCancellable *cancellable,
5428     GError **error)
5429 {
5430   GVariant *_ret;
5431   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5432     "LinuxLvm2LVStart",
5433     g_variant_new ("(ss^as)",
5434                    arg_group_uuid,
5435                    arg_uuid,
5436                    arg_options),
5437     G_DBUS_CALL_FLAGS_NONE,
5438     -1,
5439     cancellable,
5440     error);
5441   if (_ret == NULL)
5442     goto _out;
5443   g_variant_get (_ret,
5444                  "()");
5445   g_variant_unref (_ret);
5446 _out:
5447   return _ret != NULL;
5448 }
5449
5450 /**
5451  * org_freedesktop_udisks_call_linux_lvm2_lvremove:
5452  * @proxy: A #OrgFreedesktopUDisksProxy.
5453  * @arg_group_uuid: Argument to pass with the method invocation.
5454  * @arg_uuid: Argument to pass with the method invocation.
5455  * @arg_options: Argument to pass with the method invocation.
5456  * @cancellable: (allow-none): A #GCancellable or %NULL.
5457  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5458  * @user_data: User data to pass to @callback.
5459  *
5460  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVRemove">LinuxLvm2LVRemove()</link> D-Bus method on @proxy.
5461  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
5462  * You can then call org_freedesktop_udisks_call_linux_lvm2_lvremove_finish() to get the result of the operation.
5463  *
5464  * See org_freedesktop_udisks_call_linux_lvm2_lvremove_sync() for the synchronous, blocking version of this method.
5465  */
5466 void
5467 org_freedesktop_udisks_call_linux_lvm2_lvremove (
5468     OrgFreedesktopUDisks *proxy,
5469     const gchar *arg_group_uuid,
5470     const gchar *arg_uuid,
5471     const gchar *const *arg_options,
5472     GCancellable *cancellable,
5473     GAsyncReadyCallback callback,
5474     gpointer user_data)
5475 {
5476   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5477     "LinuxLvm2LVRemove",
5478     g_variant_new ("(ss^as)",
5479                    arg_group_uuid,
5480                    arg_uuid,
5481                    arg_options),
5482     G_DBUS_CALL_FLAGS_NONE,
5483     -1,
5484     cancellable,
5485     callback,
5486     user_data);
5487 }
5488
5489 /**
5490  * org_freedesktop_udisks_call_linux_lvm2_lvremove_finish:
5491  * @proxy: A #OrgFreedesktopUDisksProxy.
5492  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_linux_lvm2_lvremove().
5493  * @error: Return location for error or %NULL.
5494  *
5495  * Finishes an operation started with org_freedesktop_udisks_call_linux_lvm2_lvremove().
5496  *
5497  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5498  */
5499 gboolean
5500 org_freedesktop_udisks_call_linux_lvm2_lvremove_finish (
5501     OrgFreedesktopUDisks *proxy,
5502     GAsyncResult *res,
5503     GError **error)
5504 {
5505   GVariant *_ret;
5506   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5507   if (_ret == NULL)
5508     goto _out;
5509   g_variant_get (_ret,
5510                  "()");
5511   g_variant_unref (_ret);
5512 _out:
5513   return _ret != NULL;
5514 }
5515
5516 /**
5517  * org_freedesktop_udisks_call_linux_lvm2_lvremove_sync:
5518  * @proxy: A #OrgFreedesktopUDisksProxy.
5519  * @arg_group_uuid: Argument to pass with the method invocation.
5520  * @arg_uuid: Argument to pass with the method invocation.
5521  * @arg_options: Argument to pass with the method invocation.
5522  * @cancellable: (allow-none): A #GCancellable or %NULL.
5523  * @error: Return location for error or %NULL.
5524  *
5525  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVRemove">LinuxLvm2LVRemove()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5526  *
5527  * See org_freedesktop_udisks_call_linux_lvm2_lvremove() for the asynchronous version of this method.
5528  *
5529  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5530  */
5531 gboolean
5532 org_freedesktop_udisks_call_linux_lvm2_lvremove_sync (
5533     OrgFreedesktopUDisks *proxy,
5534     const gchar *arg_group_uuid,
5535     const gchar *arg_uuid,
5536     const gchar *const *arg_options,
5537     GCancellable *cancellable,
5538     GError **error)
5539 {
5540   GVariant *_ret;
5541   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5542     "LinuxLvm2LVRemove",
5543     g_variant_new ("(ss^as)",
5544                    arg_group_uuid,
5545                    arg_uuid,
5546                    arg_options),
5547     G_DBUS_CALL_FLAGS_NONE,
5548     -1,
5549     cancellable,
5550     error);
5551   if (_ret == NULL)
5552     goto _out;
5553   g_variant_get (_ret,
5554                  "()");
5555   g_variant_unref (_ret);
5556 _out:
5557   return _ret != NULL;
5558 }
5559
5560 /**
5561  * org_freedesktop_udisks_call_linux_lvm2_lvcreate:
5562  * @proxy: A #OrgFreedesktopUDisksProxy.
5563  * @arg_group_uuid: Argument to pass with the method invocation.
5564  * @arg_name: Argument to pass with the method invocation.
5565  * @arg_size: Argument to pass with the method invocation.
5566  * @arg_num_stripes: Argument to pass with the method invocation.
5567  * @arg_stripe_size: Argument to pass with the method invocation.
5568  * @arg_num_mirrors: Argument to pass with the method invocation.
5569  * @arg_options: Argument to pass with the method invocation.
5570  * @arg_fstype: Argument to pass with the method invocation.
5571  * @arg_fsoptions: Argument to pass with the method invocation.
5572  * @cancellable: (allow-none): A #GCancellable or %NULL.
5573  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5574  * @user_data: User data to pass to @callback.
5575  *
5576  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVCreate">LinuxLvm2LVCreate()</link> D-Bus method on @proxy.
5577  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
5578  * You can then call org_freedesktop_udisks_call_linux_lvm2_lvcreate_finish() to get the result of the operation.
5579  *
5580  * See org_freedesktop_udisks_call_linux_lvm2_lvcreate_sync() for the synchronous, blocking version of this method.
5581  */
5582 void
5583 org_freedesktop_udisks_call_linux_lvm2_lvcreate (
5584     OrgFreedesktopUDisks *proxy,
5585     const gchar *arg_group_uuid,
5586     const gchar *arg_name,
5587     guint64 arg_size,
5588     guint arg_num_stripes,
5589     guint64 arg_stripe_size,
5590     guint arg_num_mirrors,
5591     const gchar *const *arg_options,
5592     const gchar *arg_fstype,
5593     const gchar *const *arg_fsoptions,
5594     GCancellable *cancellable,
5595     GAsyncReadyCallback callback,
5596     gpointer user_data)
5597 {
5598   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5599     "LinuxLvm2LVCreate",
5600     g_variant_new ("(sstutu^ass^as)",
5601                    arg_group_uuid,
5602                    arg_name,
5603                    arg_size,
5604                    arg_num_stripes,
5605                    arg_stripe_size,
5606                    arg_num_mirrors,
5607                    arg_options,
5608                    arg_fstype,
5609                    arg_fsoptions),
5610     G_DBUS_CALL_FLAGS_NONE,
5611     -1,
5612     cancellable,
5613     callback,
5614     user_data);
5615 }
5616
5617 /**
5618  * org_freedesktop_udisks_call_linux_lvm2_lvcreate_finish:
5619  * @proxy: A #OrgFreedesktopUDisksProxy.
5620  * @out_created_device: (out): Return location for return parameter or %NULL to ignore.
5621  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_linux_lvm2_lvcreate().
5622  * @error: Return location for error or %NULL.
5623  *
5624  * Finishes an operation started with org_freedesktop_udisks_call_linux_lvm2_lvcreate().
5625  *
5626  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5627  */
5628 gboolean
5629 org_freedesktop_udisks_call_linux_lvm2_lvcreate_finish (
5630     OrgFreedesktopUDisks *proxy,
5631     gchar **out_created_device,
5632     GAsyncResult *res,
5633     GError **error)
5634 {
5635   GVariant *_ret;
5636   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5637   if (_ret == NULL)
5638     goto _out;
5639   g_variant_get (_ret,
5640                  "(o)",
5641                  out_created_device);
5642   g_variant_unref (_ret);
5643 _out:
5644   return _ret != NULL;
5645 }
5646
5647 /**
5648  * org_freedesktop_udisks_call_linux_lvm2_lvcreate_sync:
5649  * @proxy: A #OrgFreedesktopUDisksProxy.
5650  * @arg_group_uuid: Argument to pass with the method invocation.
5651  * @arg_name: Argument to pass with the method invocation.
5652  * @arg_size: Argument to pass with the method invocation.
5653  * @arg_num_stripes: Argument to pass with the method invocation.
5654  * @arg_stripe_size: Argument to pass with the method invocation.
5655  * @arg_num_mirrors: Argument to pass with the method invocation.
5656  * @arg_options: Argument to pass with the method invocation.
5657  * @arg_fstype: Argument to pass with the method invocation.
5658  * @arg_fsoptions: Argument to pass with the method invocation.
5659  * @out_created_device: (out): Return location for return parameter or %NULL to ignore.
5660  * @cancellable: (allow-none): A #GCancellable or %NULL.
5661  * @error: Return location for error or %NULL.
5662  *
5663  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVCreate">LinuxLvm2LVCreate()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5664  *
5665  * See org_freedesktop_udisks_call_linux_lvm2_lvcreate() for the asynchronous version of this method.
5666  *
5667  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5668  */
5669 gboolean
5670 org_freedesktop_udisks_call_linux_lvm2_lvcreate_sync (
5671     OrgFreedesktopUDisks *proxy,
5672     const gchar *arg_group_uuid,
5673     const gchar *arg_name,
5674     guint64 arg_size,
5675     guint arg_num_stripes,
5676     guint64 arg_stripe_size,
5677     guint arg_num_mirrors,
5678     const gchar *const *arg_options,
5679     const gchar *arg_fstype,
5680     const gchar *const *arg_fsoptions,
5681     gchar **out_created_device,
5682     GCancellable *cancellable,
5683     GError **error)
5684 {
5685   GVariant *_ret;
5686   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5687     "LinuxLvm2LVCreate",
5688     g_variant_new ("(sstutu^ass^as)",
5689                    arg_group_uuid,
5690                    arg_name,
5691                    arg_size,
5692                    arg_num_stripes,
5693                    arg_stripe_size,
5694                    arg_num_mirrors,
5695                    arg_options,
5696                    arg_fstype,
5697                    arg_fsoptions),
5698     G_DBUS_CALL_FLAGS_NONE,
5699     -1,
5700     cancellable,
5701     error);
5702   if (_ret == NULL)
5703     goto _out;
5704   g_variant_get (_ret,
5705                  "(o)",
5706                  out_created_device);
5707   g_variant_unref (_ret);
5708 _out:
5709   return _ret != NULL;
5710 }
5711
5712 /**
5713  * org_freedesktop_udisks_call_linux_md_start:
5714  * @proxy: A #OrgFreedesktopUDisksProxy.
5715  * @arg_components: Argument to pass with the method invocation.
5716  * @arg_options: Argument to pass with the method invocation.
5717  * @cancellable: (allow-none): A #GCancellable or %NULL.
5718  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5719  * @user_data: User data to pass to @callback.
5720  *
5721  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxMdStart">LinuxMdStart()</link> D-Bus method on @proxy.
5722  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
5723  * You can then call org_freedesktop_udisks_call_linux_md_start_finish() to get the result of the operation.
5724  *
5725  * See org_freedesktop_udisks_call_linux_md_start_sync() for the synchronous, blocking version of this method.
5726  */
5727 void
5728 org_freedesktop_udisks_call_linux_md_start (
5729     OrgFreedesktopUDisks *proxy,
5730     const gchar *const *arg_components,
5731     const gchar *const *arg_options,
5732     GCancellable *cancellable,
5733     GAsyncReadyCallback callback,
5734     gpointer user_data)
5735 {
5736   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5737     "LinuxMdStart",
5738     g_variant_new ("(^ao^as)",
5739                    arg_components,
5740                    arg_options),
5741     G_DBUS_CALL_FLAGS_NONE,
5742     -1,
5743     cancellable,
5744     callback,
5745     user_data);
5746 }
5747
5748 /**
5749  * org_freedesktop_udisks_call_linux_md_start_finish:
5750  * @proxy: A #OrgFreedesktopUDisksProxy.
5751  * @out_device: (out): Return location for return parameter or %NULL to ignore.
5752  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_linux_md_start().
5753  * @error: Return location for error or %NULL.
5754  *
5755  * Finishes an operation started with org_freedesktop_udisks_call_linux_md_start().
5756  *
5757  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5758  */
5759 gboolean
5760 org_freedesktop_udisks_call_linux_md_start_finish (
5761     OrgFreedesktopUDisks *proxy,
5762     gchar **out_device,
5763     GAsyncResult *res,
5764     GError **error)
5765 {
5766   GVariant *_ret;
5767   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5768   if (_ret == NULL)
5769     goto _out;
5770   g_variant_get (_ret,
5771                  "(o)",
5772                  out_device);
5773   g_variant_unref (_ret);
5774 _out:
5775   return _ret != NULL;
5776 }
5777
5778 /**
5779  * org_freedesktop_udisks_call_linux_md_start_sync:
5780  * @proxy: A #OrgFreedesktopUDisksProxy.
5781  * @arg_components: Argument to pass with the method invocation.
5782  * @arg_options: Argument to pass with the method invocation.
5783  * @out_device: (out): Return location for return parameter or %NULL to ignore.
5784  * @cancellable: (allow-none): A #GCancellable or %NULL.
5785  * @error: Return location for error or %NULL.
5786  *
5787  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxMdStart">LinuxMdStart()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5788  *
5789  * See org_freedesktop_udisks_call_linux_md_start() for the asynchronous version of this method.
5790  *
5791  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5792  */
5793 gboolean
5794 org_freedesktop_udisks_call_linux_md_start_sync (
5795     OrgFreedesktopUDisks *proxy,
5796     const gchar *const *arg_components,
5797     const gchar *const *arg_options,
5798     gchar **out_device,
5799     GCancellable *cancellable,
5800     GError **error)
5801 {
5802   GVariant *_ret;
5803   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5804     "LinuxMdStart",
5805     g_variant_new ("(^ao^as)",
5806                    arg_components,
5807                    arg_options),
5808     G_DBUS_CALL_FLAGS_NONE,
5809     -1,
5810     cancellable,
5811     error);
5812   if (_ret == NULL)
5813     goto _out;
5814   g_variant_get (_ret,
5815                  "(o)",
5816                  out_device);
5817   g_variant_unref (_ret);
5818 _out:
5819   return _ret != NULL;
5820 }
5821
5822 /**
5823  * org_freedesktop_udisks_call_linux_md_create:
5824  * @proxy: A #OrgFreedesktopUDisksProxy.
5825  * @arg_components: Argument to pass with the method invocation.
5826  * @arg_level: Argument to pass with the method invocation.
5827  * @arg_stripe_size: Argument to pass with the method invocation.
5828  * @arg_name: Argument to pass with the method invocation.
5829  * @arg_options: Argument to pass with the method invocation.
5830  * @cancellable: (allow-none): A #GCancellable or %NULL.
5831  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5832  * @user_data: User data to pass to @callback.
5833  *
5834  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxMdCreate">LinuxMdCreate()</link> D-Bus method on @proxy.
5835  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
5836  * You can then call org_freedesktop_udisks_call_linux_md_create_finish() to get the result of the operation.
5837  *
5838  * See org_freedesktop_udisks_call_linux_md_create_sync() for the synchronous, blocking version of this method.
5839  */
5840 void
5841 org_freedesktop_udisks_call_linux_md_create (
5842     OrgFreedesktopUDisks *proxy,
5843     const gchar *const *arg_components,
5844     const gchar *arg_level,
5845     guint64 arg_stripe_size,
5846     const gchar *arg_name,
5847     const gchar *const *arg_options,
5848     GCancellable *cancellable,
5849     GAsyncReadyCallback callback,
5850     gpointer user_data)
5851 {
5852   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5853     "LinuxMdCreate",
5854     g_variant_new ("(^aosts^as)",
5855                    arg_components,
5856                    arg_level,
5857                    arg_stripe_size,
5858                    arg_name,
5859                    arg_options),
5860     G_DBUS_CALL_FLAGS_NONE,
5861     -1,
5862     cancellable,
5863     callback,
5864     user_data);
5865 }
5866
5867 /**
5868  * org_freedesktop_udisks_call_linux_md_create_finish:
5869  * @proxy: A #OrgFreedesktopUDisksProxy.
5870  * @out_device: (out): Return location for return parameter or %NULL to ignore.
5871  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_linux_md_create().
5872  * @error: Return location for error or %NULL.
5873  *
5874  * Finishes an operation started with org_freedesktop_udisks_call_linux_md_create().
5875  *
5876  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5877  */
5878 gboolean
5879 org_freedesktop_udisks_call_linux_md_create_finish (
5880     OrgFreedesktopUDisks *proxy,
5881     gchar **out_device,
5882     GAsyncResult *res,
5883     GError **error)
5884 {
5885   GVariant *_ret;
5886   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
5887   if (_ret == NULL)
5888     goto _out;
5889   g_variant_get (_ret,
5890                  "(o)",
5891                  out_device);
5892   g_variant_unref (_ret);
5893 _out:
5894   return _ret != NULL;
5895 }
5896
5897 /**
5898  * org_freedesktop_udisks_call_linux_md_create_sync:
5899  * @proxy: A #OrgFreedesktopUDisksProxy.
5900  * @arg_components: Argument to pass with the method invocation.
5901  * @arg_level: Argument to pass with the method invocation.
5902  * @arg_stripe_size: Argument to pass with the method invocation.
5903  * @arg_name: Argument to pass with the method invocation.
5904  * @arg_options: Argument to pass with the method invocation.
5905  * @out_device: (out): Return location for return parameter or %NULL to ignore.
5906  * @cancellable: (allow-none): A #GCancellable or %NULL.
5907  * @error: Return location for error or %NULL.
5908  *
5909  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxMdCreate">LinuxMdCreate()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
5910  *
5911  * See org_freedesktop_udisks_call_linux_md_create() for the asynchronous version of this method.
5912  *
5913  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5914  */
5915 gboolean
5916 org_freedesktop_udisks_call_linux_md_create_sync (
5917     OrgFreedesktopUDisks *proxy,
5918     const gchar *const *arg_components,
5919     const gchar *arg_level,
5920     guint64 arg_stripe_size,
5921     const gchar *arg_name,
5922     const gchar *const *arg_options,
5923     gchar **out_device,
5924     GCancellable *cancellable,
5925     GError **error)
5926 {
5927   GVariant *_ret;
5928   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
5929     "LinuxMdCreate",
5930     g_variant_new ("(^aosts^as)",
5931                    arg_components,
5932                    arg_level,
5933                    arg_stripe_size,
5934                    arg_name,
5935                    arg_options),
5936     G_DBUS_CALL_FLAGS_NONE,
5937     -1,
5938     cancellable,
5939     error);
5940   if (_ret == NULL)
5941     goto _out;
5942   g_variant_get (_ret,
5943                  "(o)",
5944                  out_device);
5945   g_variant_unref (_ret);
5946 _out:
5947   return _ret != NULL;
5948 }
5949
5950 /**
5951  * org_freedesktop_udisks_call_inhibit:
5952  * @proxy: A #OrgFreedesktopUDisksProxy.
5953  * @cancellable: (allow-none): A #GCancellable or %NULL.
5954  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
5955  * @user_data: User data to pass to @callback.
5956  *
5957  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.Inhibit">Inhibit()</link> D-Bus method on @proxy.
5958  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
5959  * You can then call org_freedesktop_udisks_call_inhibit_finish() to get the result of the operation.
5960  *
5961  * See org_freedesktop_udisks_call_inhibit_sync() for the synchronous, blocking version of this method.
5962  */
5963 void
5964 org_freedesktop_udisks_call_inhibit (
5965     OrgFreedesktopUDisks *proxy,
5966     GCancellable *cancellable,
5967     GAsyncReadyCallback callback,
5968     gpointer user_data)
5969 {
5970   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
5971     "Inhibit",
5972     g_variant_new ("()"),
5973     G_DBUS_CALL_FLAGS_NONE,
5974     -1,
5975     cancellable,
5976     callback,
5977     user_data);
5978 }
5979
5980 /**
5981  * org_freedesktop_udisks_call_inhibit_finish:
5982  * @proxy: A #OrgFreedesktopUDisksProxy.
5983  * @out_cookie: (out): Return location for return parameter or %NULL to ignore.
5984  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_inhibit().
5985  * @error: Return location for error or %NULL.
5986  *
5987  * Finishes an operation started with org_freedesktop_udisks_call_inhibit().
5988  *
5989  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
5990  */
5991 gboolean
5992 org_freedesktop_udisks_call_inhibit_finish (
5993     OrgFreedesktopUDisks *proxy,
5994     gchar **out_cookie,
5995     GAsyncResult *res,
5996     GError **error)
5997 {
5998   GVariant *_ret;
5999   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
6000   if (_ret == NULL)
6001     goto _out;
6002   g_variant_get (_ret,
6003                  "(s)",
6004                  out_cookie);
6005   g_variant_unref (_ret);
6006 _out:
6007   return _ret != NULL;
6008 }
6009
6010 /**
6011  * org_freedesktop_udisks_call_inhibit_sync:
6012  * @proxy: A #OrgFreedesktopUDisksProxy.
6013  * @out_cookie: (out): Return location for return parameter or %NULL to ignore.
6014  * @cancellable: (allow-none): A #GCancellable or %NULL.
6015  * @error: Return location for error or %NULL.
6016  *
6017  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.Inhibit">Inhibit()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
6018  *
6019  * See org_freedesktop_udisks_call_inhibit() for the asynchronous version of this method.
6020  *
6021  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
6022  */
6023 gboolean
6024 org_freedesktop_udisks_call_inhibit_sync (
6025     OrgFreedesktopUDisks *proxy,
6026     gchar **out_cookie,
6027     GCancellable *cancellable,
6028     GError **error)
6029 {
6030   GVariant *_ret;
6031   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
6032     "Inhibit",
6033     g_variant_new ("()"),
6034     G_DBUS_CALL_FLAGS_NONE,
6035     -1,
6036     cancellable,
6037     error);
6038   if (_ret == NULL)
6039     goto _out;
6040   g_variant_get (_ret,
6041                  "(s)",
6042                  out_cookie);
6043   g_variant_unref (_ret);
6044 _out:
6045   return _ret != NULL;
6046 }
6047
6048 /**
6049  * org_freedesktop_udisks_call_uninhibit:
6050  * @proxy: A #OrgFreedesktopUDisksProxy.
6051  * @arg_cookie: Argument to pass with the method invocation.
6052  * @cancellable: (allow-none): A #GCancellable or %NULL.
6053  * @callback: A #GAsyncReadyCallback to call when the request is satisfied or %NULL.
6054  * @user_data: User data to pass to @callback.
6055  *
6056  * Asynchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.Uninhibit">Uninhibit()</link> D-Bus method on @proxy.
6057  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
6058  * You can then call org_freedesktop_udisks_call_uninhibit_finish() to get the result of the operation.
6059  *
6060  * See org_freedesktop_udisks_call_uninhibit_sync() for the synchronous, blocking version of this method.
6061  */
6062 void
6063 org_freedesktop_udisks_call_uninhibit (
6064     OrgFreedesktopUDisks *proxy,
6065     const gchar *arg_cookie,
6066     GCancellable *cancellable,
6067     GAsyncReadyCallback callback,
6068     gpointer user_data)
6069 {
6070   g_dbus_proxy_call (G_DBUS_PROXY (proxy),
6071     "Uninhibit",
6072     g_variant_new ("(s)",
6073                    arg_cookie),
6074     G_DBUS_CALL_FLAGS_NONE,
6075     -1,
6076     cancellable,
6077     callback,
6078     user_data);
6079 }
6080
6081 /**
6082  * org_freedesktop_udisks_call_uninhibit_finish:
6083  * @proxy: A #OrgFreedesktopUDisksProxy.
6084  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_call_uninhibit().
6085  * @error: Return location for error or %NULL.
6086  *
6087  * Finishes an operation started with org_freedesktop_udisks_call_uninhibit().
6088  *
6089  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
6090  */
6091 gboolean
6092 org_freedesktop_udisks_call_uninhibit_finish (
6093     OrgFreedesktopUDisks *proxy,
6094     GAsyncResult *res,
6095     GError **error)
6096 {
6097   GVariant *_ret;
6098   _ret = g_dbus_proxy_call_finish (G_DBUS_PROXY (proxy), res, error);
6099   if (_ret == NULL)
6100     goto _out;
6101   g_variant_get (_ret,
6102                  "()");
6103   g_variant_unref (_ret);
6104 _out:
6105   return _ret != NULL;
6106 }
6107
6108 /**
6109  * org_freedesktop_udisks_call_uninhibit_sync:
6110  * @proxy: A #OrgFreedesktopUDisksProxy.
6111  * @arg_cookie: Argument to pass with the method invocation.
6112  * @cancellable: (allow-none): A #GCancellable or %NULL.
6113  * @error: Return location for error or %NULL.
6114  *
6115  * Synchronously invokes the <link linkend="gdbus-method-org-freedesktop-UDisks.Uninhibit">Uninhibit()</link> D-Bus method on @proxy. The calling thread is blocked until a reply is received.
6116  *
6117  * See org_freedesktop_udisks_call_uninhibit() for the asynchronous version of this method.
6118  *
6119  * Returns: (skip): %TRUE if the call succeded, %FALSE if @error is set.
6120  */
6121 gboolean
6122 org_freedesktop_udisks_call_uninhibit_sync (
6123     OrgFreedesktopUDisks *proxy,
6124     const gchar *arg_cookie,
6125     GCancellable *cancellable,
6126     GError **error)
6127 {
6128   GVariant *_ret;
6129   _ret = g_dbus_proxy_call_sync (G_DBUS_PROXY (proxy),
6130     "Uninhibit",
6131     g_variant_new ("(s)",
6132                    arg_cookie),
6133     G_DBUS_CALL_FLAGS_NONE,
6134     -1,
6135     cancellable,
6136     error);
6137   if (_ret == NULL)
6138     goto _out;
6139   g_variant_get (_ret,
6140                  "()");
6141   g_variant_unref (_ret);
6142 _out:
6143   return _ret != NULL;
6144 }
6145
6146 /**
6147  * org_freedesktop_udisks_complete_enumerate_adapters:
6148  * @object: A #OrgFreedesktopUDisks.
6149  * @invocation: (transfer full): A #GDBusMethodInvocation.
6150  * @devices: Parameter to return.
6151  *
6152  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateAdapters">EnumerateAdapters()</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.
6153  *
6154  * This method will free @invocation, you cannot use it afterwards.
6155  */
6156 void
6157 org_freedesktop_udisks_complete_enumerate_adapters (
6158     OrgFreedesktopUDisks *object,
6159     GDBusMethodInvocation *invocation,
6160     const gchar *const *devices)
6161 {
6162   g_dbus_method_invocation_return_value (invocation,
6163     g_variant_new ("(^ao)",
6164                    devices));
6165 }
6166
6167 /**
6168  * org_freedesktop_udisks_complete_enumerate_expanders:
6169  * @object: A #OrgFreedesktopUDisks.
6170  * @invocation: (transfer full): A #GDBusMethodInvocation.
6171  * @devices: Parameter to return.
6172  *
6173  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateExpanders">EnumerateExpanders()</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.
6174  *
6175  * This method will free @invocation, you cannot use it afterwards.
6176  */
6177 void
6178 org_freedesktop_udisks_complete_enumerate_expanders (
6179     OrgFreedesktopUDisks *object,
6180     GDBusMethodInvocation *invocation,
6181     const gchar *const *devices)
6182 {
6183   g_dbus_method_invocation_return_value (invocation,
6184     g_variant_new ("(^ao)",
6185                    devices));
6186 }
6187
6188 /**
6189  * org_freedesktop_udisks_complete_enumerate_ports:
6190  * @object: A #OrgFreedesktopUDisks.
6191  * @invocation: (transfer full): A #GDBusMethodInvocation.
6192  * @devices: Parameter to return.
6193  *
6194  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumeratePorts">EnumeratePorts()</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.
6195  *
6196  * This method will free @invocation, you cannot use it afterwards.
6197  */
6198 void
6199 org_freedesktop_udisks_complete_enumerate_ports (
6200     OrgFreedesktopUDisks *object,
6201     GDBusMethodInvocation *invocation,
6202     const gchar *const *devices)
6203 {
6204   g_dbus_method_invocation_return_value (invocation,
6205     g_variant_new ("(^ao)",
6206                    devices));
6207 }
6208
6209 /**
6210  * org_freedesktop_udisks_complete_enumerate_devices:
6211  * @object: A #OrgFreedesktopUDisks.
6212  * @invocation: (transfer full): A #GDBusMethodInvocation.
6213  * @devices: Parameter to return.
6214  *
6215  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateDevices">EnumerateDevices()</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.
6216  *
6217  * This method will free @invocation, you cannot use it afterwards.
6218  */
6219 void
6220 org_freedesktop_udisks_complete_enumerate_devices (
6221     OrgFreedesktopUDisks *object,
6222     GDBusMethodInvocation *invocation,
6223     const gchar *const *devices)
6224 {
6225   g_dbus_method_invocation_return_value (invocation,
6226     g_variant_new ("(^ao)",
6227                    devices));
6228 }
6229
6230 /**
6231  * org_freedesktop_udisks_complete_enumerate_device_files:
6232  * @object: A #OrgFreedesktopUDisks.
6233  * @invocation: (transfer full): A #GDBusMethodInvocation.
6234  * @device_files: Parameter to return.
6235  *
6236  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.EnumerateDeviceFiles">EnumerateDeviceFiles()</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.
6237  *
6238  * This method will free @invocation, you cannot use it afterwards.
6239  */
6240 void
6241 org_freedesktop_udisks_complete_enumerate_device_files (
6242     OrgFreedesktopUDisks *object,
6243     GDBusMethodInvocation *invocation,
6244     const gchar *const *device_files)
6245 {
6246   g_dbus_method_invocation_return_value (invocation,
6247     g_variant_new ("(^as)",
6248                    device_files));
6249 }
6250
6251 /**
6252  * org_freedesktop_udisks_complete_find_device_by_device_file:
6253  * @object: A #OrgFreedesktopUDisks.
6254  * @invocation: (transfer full): A #GDBusMethodInvocation.
6255  * @device: Parameter to return.
6256  *
6257  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.FindDeviceByDeviceFile">FindDeviceByDeviceFile()</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.
6258  *
6259  * This method will free @invocation, you cannot use it afterwards.
6260  */
6261 void
6262 org_freedesktop_udisks_complete_find_device_by_device_file (
6263     OrgFreedesktopUDisks *object,
6264     GDBusMethodInvocation *invocation,
6265     const gchar *device)
6266 {
6267   g_dbus_method_invocation_return_value (invocation,
6268     g_variant_new ("(o)",
6269                    device));
6270 }
6271
6272 /**
6273  * org_freedesktop_udisks_complete_find_device_by_major_minor:
6274  * @object: A #OrgFreedesktopUDisks.
6275  * @invocation: (transfer full): A #GDBusMethodInvocation.
6276  * @device: Parameter to return.
6277  *
6278  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.FindDeviceByMajorMinor">FindDeviceByMajorMinor()</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.
6279  *
6280  * This method will free @invocation, you cannot use it afterwards.
6281  */
6282 void
6283 org_freedesktop_udisks_complete_find_device_by_major_minor (
6284     OrgFreedesktopUDisks *object,
6285     GDBusMethodInvocation *invocation,
6286     const gchar *device)
6287 {
6288   g_dbus_method_invocation_return_value (invocation,
6289     g_variant_new ("(o)",
6290                    device));
6291 }
6292
6293 /**
6294  * org_freedesktop_udisks_complete_drive_inhibit_all_polling:
6295  * @object: A #OrgFreedesktopUDisks.
6296  * @invocation: (transfer full): A #GDBusMethodInvocation.
6297  * @cookie: Parameter to return.
6298  *
6299  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveInhibitAllPolling">DriveInhibitAllPolling()</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.
6300  *
6301  * This method will free @invocation, you cannot use it afterwards.
6302  */
6303 void
6304 org_freedesktop_udisks_complete_drive_inhibit_all_polling (
6305     OrgFreedesktopUDisks *object,
6306     GDBusMethodInvocation *invocation,
6307     const gchar *cookie)
6308 {
6309   g_dbus_method_invocation_return_value (invocation,
6310     g_variant_new ("(s)",
6311                    cookie));
6312 }
6313
6314 /**
6315  * org_freedesktop_udisks_complete_drive_uninhibit_all_polling:
6316  * @object: A #OrgFreedesktopUDisks.
6317  * @invocation: (transfer full): A #GDBusMethodInvocation.
6318  *
6319  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveUninhibitAllPolling">DriveUninhibitAllPolling()</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.
6320  *
6321  * This method will free @invocation, you cannot use it afterwards.
6322  */
6323 void
6324 org_freedesktop_udisks_complete_drive_uninhibit_all_polling (
6325     OrgFreedesktopUDisks *object,
6326     GDBusMethodInvocation *invocation)
6327 {
6328   g_dbus_method_invocation_return_value (invocation,
6329     g_variant_new ("()"));
6330 }
6331
6332 /**
6333  * org_freedesktop_udisks_complete_drive_set_all_spindown_timeouts:
6334  * @object: A #OrgFreedesktopUDisks.
6335  * @invocation: (transfer full): A #GDBusMethodInvocation.
6336  * @cookie: Parameter to return.
6337  *
6338  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveSetAllSpindownTimeouts">DriveSetAllSpindownTimeouts()</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.
6339  *
6340  * This method will free @invocation, you cannot use it afterwards.
6341  */
6342 void
6343 org_freedesktop_udisks_complete_drive_set_all_spindown_timeouts (
6344     OrgFreedesktopUDisks *object,
6345     GDBusMethodInvocation *invocation,
6346     const gchar *cookie)
6347 {
6348   g_dbus_method_invocation_return_value (invocation,
6349     g_variant_new ("(s)",
6350                    cookie));
6351 }
6352
6353 /**
6354  * org_freedesktop_udisks_complete_drive_unset_all_spindown_timeouts:
6355  * @object: A #OrgFreedesktopUDisks.
6356  * @invocation: (transfer full): A #GDBusMethodInvocation.
6357  *
6358  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.DriveUnsetAllSpindownTimeouts">DriveUnsetAllSpindownTimeouts()</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.
6359  *
6360  * This method will free @invocation, you cannot use it afterwards.
6361  */
6362 void
6363 org_freedesktop_udisks_complete_drive_unset_all_spindown_timeouts (
6364     OrgFreedesktopUDisks *object,
6365     GDBusMethodInvocation *invocation)
6366 {
6367   g_dbus_method_invocation_return_value (invocation,
6368     g_variant_new ("()"));
6369 }
6370
6371 /**
6372  * org_freedesktop_udisks_complete_linux_lvm2_vgstart:
6373  * @object: A #OrgFreedesktopUDisks.
6374  * @invocation: (transfer full): A #GDBusMethodInvocation.
6375  *
6376  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGStart">LinuxLvm2VGStart()</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.
6377  *
6378  * This method will free @invocation, you cannot use it afterwards.
6379  */
6380 void
6381 org_freedesktop_udisks_complete_linux_lvm2_vgstart (
6382     OrgFreedesktopUDisks *object,
6383     GDBusMethodInvocation *invocation)
6384 {
6385   g_dbus_method_invocation_return_value (invocation,
6386     g_variant_new ("()"));
6387 }
6388
6389 /**
6390  * org_freedesktop_udisks_complete_linux_lvm2_vgstop:
6391  * @object: A #OrgFreedesktopUDisks.
6392  * @invocation: (transfer full): A #GDBusMethodInvocation.
6393  *
6394  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGStop">LinuxLvm2VGStop()</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.
6395  *
6396  * This method will free @invocation, you cannot use it afterwards.
6397  */
6398 void
6399 org_freedesktop_udisks_complete_linux_lvm2_vgstop (
6400     OrgFreedesktopUDisks *object,
6401     GDBusMethodInvocation *invocation)
6402 {
6403   g_dbus_method_invocation_return_value (invocation,
6404     g_variant_new ("()"));
6405 }
6406
6407 /**
6408  * org_freedesktop_udisks_complete_linux_lvm2_vgset_name:
6409  * @object: A #OrgFreedesktopUDisks.
6410  * @invocation: (transfer full): A #GDBusMethodInvocation.
6411  *
6412  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGSetName">LinuxLvm2VGSetName()</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.
6413  *
6414  * This method will free @invocation, you cannot use it afterwards.
6415  */
6416 void
6417 org_freedesktop_udisks_complete_linux_lvm2_vgset_name (
6418     OrgFreedesktopUDisks *object,
6419     GDBusMethodInvocation *invocation)
6420 {
6421   g_dbus_method_invocation_return_value (invocation,
6422     g_variant_new ("()"));
6423 }
6424
6425 /**
6426  * org_freedesktop_udisks_complete_linux_lvm2_vgadd_pv:
6427  * @object: A #OrgFreedesktopUDisks.
6428  * @invocation: (transfer full): A #GDBusMethodInvocation.
6429  *
6430  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGAddPV">LinuxLvm2VGAddPV()</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.
6431  *
6432  * This method will free @invocation, you cannot use it afterwards.
6433  */
6434 void
6435 org_freedesktop_udisks_complete_linux_lvm2_vgadd_pv (
6436     OrgFreedesktopUDisks *object,
6437     GDBusMethodInvocation *invocation)
6438 {
6439   g_dbus_method_invocation_return_value (invocation,
6440     g_variant_new ("()"));
6441 }
6442
6443 /**
6444  * org_freedesktop_udisks_complete_linux_lvm2_vgremove_pv:
6445  * @object: A #OrgFreedesktopUDisks.
6446  * @invocation: (transfer full): A #GDBusMethodInvocation.
6447  *
6448  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2VGRemovePV">LinuxLvm2VGRemovePV()</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.
6449  *
6450  * This method will free @invocation, you cannot use it afterwards.
6451  */
6452 void
6453 org_freedesktop_udisks_complete_linux_lvm2_vgremove_pv (
6454     OrgFreedesktopUDisks *object,
6455     GDBusMethodInvocation *invocation)
6456 {
6457   g_dbus_method_invocation_return_value (invocation,
6458     g_variant_new ("()"));
6459 }
6460
6461 /**
6462  * org_freedesktop_udisks_complete_linux_lvm2_lvset_name:
6463  * @object: A #OrgFreedesktopUDisks.
6464  * @invocation: (transfer full): A #GDBusMethodInvocation.
6465  *
6466  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVSetName">LinuxLvm2LVSetName()</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.
6467  *
6468  * This method will free @invocation, you cannot use it afterwards.
6469  */
6470 void
6471 org_freedesktop_udisks_complete_linux_lvm2_lvset_name (
6472     OrgFreedesktopUDisks *object,
6473     GDBusMethodInvocation *invocation)
6474 {
6475   g_dbus_method_invocation_return_value (invocation,
6476     g_variant_new ("()"));
6477 }
6478
6479 /**
6480  * org_freedesktop_udisks_complete_linux_lvm2_lvstart:
6481  * @object: A #OrgFreedesktopUDisks.
6482  * @invocation: (transfer full): A #GDBusMethodInvocation.
6483  *
6484  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVStart">LinuxLvm2LVStart()</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.
6485  *
6486  * This method will free @invocation, you cannot use it afterwards.
6487  */
6488 void
6489 org_freedesktop_udisks_complete_linux_lvm2_lvstart (
6490     OrgFreedesktopUDisks *object,
6491     GDBusMethodInvocation *invocation)
6492 {
6493   g_dbus_method_invocation_return_value (invocation,
6494     g_variant_new ("()"));
6495 }
6496
6497 /**
6498  * org_freedesktop_udisks_complete_linux_lvm2_lvremove:
6499  * @object: A #OrgFreedesktopUDisks.
6500  * @invocation: (transfer full): A #GDBusMethodInvocation.
6501  *
6502  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVRemove">LinuxLvm2LVRemove()</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.
6503  *
6504  * This method will free @invocation, you cannot use it afterwards.
6505  */
6506 void
6507 org_freedesktop_udisks_complete_linux_lvm2_lvremove (
6508     OrgFreedesktopUDisks *object,
6509     GDBusMethodInvocation *invocation)
6510 {
6511   g_dbus_method_invocation_return_value (invocation,
6512     g_variant_new ("()"));
6513 }
6514
6515 /**
6516  * org_freedesktop_udisks_complete_linux_lvm2_lvcreate:
6517  * @object: A #OrgFreedesktopUDisks.
6518  * @invocation: (transfer full): A #GDBusMethodInvocation.
6519  * @created_device: Parameter to return.
6520  *
6521  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxLvm2LVCreate">LinuxLvm2LVCreate()</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.
6522  *
6523  * This method will free @invocation, you cannot use it afterwards.
6524  */
6525 void
6526 org_freedesktop_udisks_complete_linux_lvm2_lvcreate (
6527     OrgFreedesktopUDisks *object,
6528     GDBusMethodInvocation *invocation,
6529     const gchar *created_device)
6530 {
6531   g_dbus_method_invocation_return_value (invocation,
6532     g_variant_new ("(o)",
6533                    created_device));
6534 }
6535
6536 /**
6537  * org_freedesktop_udisks_complete_linux_md_start:
6538  * @object: A #OrgFreedesktopUDisks.
6539  * @invocation: (transfer full): A #GDBusMethodInvocation.
6540  * @device: Parameter to return.
6541  *
6542  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxMdStart">LinuxMdStart()</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.
6543  *
6544  * This method will free @invocation, you cannot use it afterwards.
6545  */
6546 void
6547 org_freedesktop_udisks_complete_linux_md_start (
6548     OrgFreedesktopUDisks *object,
6549     GDBusMethodInvocation *invocation,
6550     const gchar *device)
6551 {
6552   g_dbus_method_invocation_return_value (invocation,
6553     g_variant_new ("(o)",
6554                    device));
6555 }
6556
6557 /**
6558  * org_freedesktop_udisks_complete_linux_md_create:
6559  * @object: A #OrgFreedesktopUDisks.
6560  * @invocation: (transfer full): A #GDBusMethodInvocation.
6561  * @device: Parameter to return.
6562  *
6563  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.LinuxMdCreate">LinuxMdCreate()</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.
6564  *
6565  * This method will free @invocation, you cannot use it afterwards.
6566  */
6567 void
6568 org_freedesktop_udisks_complete_linux_md_create (
6569     OrgFreedesktopUDisks *object,
6570     GDBusMethodInvocation *invocation,
6571     const gchar *device)
6572 {
6573   g_dbus_method_invocation_return_value (invocation,
6574     g_variant_new ("(o)",
6575                    device));
6576 }
6577
6578 /**
6579  * org_freedesktop_udisks_complete_inhibit:
6580  * @object: A #OrgFreedesktopUDisks.
6581  * @invocation: (transfer full): A #GDBusMethodInvocation.
6582  * @cookie: Parameter to return.
6583  *
6584  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.Inhibit">Inhibit()</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.
6585  *
6586  * This method will free @invocation, you cannot use it afterwards.
6587  */
6588 void
6589 org_freedesktop_udisks_complete_inhibit (
6590     OrgFreedesktopUDisks *object,
6591     GDBusMethodInvocation *invocation,
6592     const gchar *cookie)
6593 {
6594   g_dbus_method_invocation_return_value (invocation,
6595     g_variant_new ("(s)",
6596                    cookie));
6597 }
6598
6599 /**
6600  * org_freedesktop_udisks_complete_uninhibit:
6601  * @object: A #OrgFreedesktopUDisks.
6602  * @invocation: (transfer full): A #GDBusMethodInvocation.
6603  *
6604  * Helper function used in service implementations to finish handling invocations of the <link linkend="gdbus-method-org-freedesktop-UDisks.Uninhibit">Uninhibit()</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.
6605  *
6606  * This method will free @invocation, you cannot use it afterwards.
6607  */
6608 void
6609 org_freedesktop_udisks_complete_uninhibit (
6610     OrgFreedesktopUDisks *object,
6611     GDBusMethodInvocation *invocation)
6612 {
6613   g_dbus_method_invocation_return_value (invocation,
6614     g_variant_new ("()"));
6615 }
6616
6617 /* ------------------------------------------------------------------------ */
6618
6619 /**
6620  * OrgFreedesktopUDisksProxy:
6621  *
6622  * The #OrgFreedesktopUDisksProxy structure contains only private data and should only be accessed using the provided API.
6623  */
6624
6625 /**
6626  * OrgFreedesktopUDisksProxyClass:
6627  * @parent_class: The parent class.
6628  *
6629  * Class structure for #OrgFreedesktopUDisksProxy.
6630  */
6631
6632 struct _OrgFreedesktopUDisksProxyPrivate
6633 {
6634   GData *qdata;
6635 };
6636
6637 static void org_freedesktop_udisks_proxy_iface_init (OrgFreedesktopUDisksIface *iface);
6638
6639 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
6640 G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopUDisksProxy, org_freedesktop_udisks_proxy, G_TYPE_DBUS_PROXY,
6641                          G_ADD_PRIVATE (OrgFreedesktopUDisksProxy)
6642                          G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_UDISKS, org_freedesktop_udisks_proxy_iface_init));
6643
6644 #else
6645 G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopUDisksProxy, org_freedesktop_udisks_proxy, G_TYPE_DBUS_PROXY,
6646                          G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_UDISKS, org_freedesktop_udisks_proxy_iface_init));
6647
6648 #endif
6649 static void
6650 org_freedesktop_udisks_proxy_finalize (GObject *object)
6651 {
6652   OrgFreedesktopUDisksProxy *proxy = ORG_FREEDESKTOP_UDISKS_PROXY (object);
6653   g_datalist_clear (&proxy->priv->qdata);
6654   G_OBJECT_CLASS (org_freedesktop_udisks_proxy_parent_class)->finalize (object);
6655 }
6656
6657 static void
6658 org_freedesktop_udisks_proxy_get_property (GObject      *object,
6659   guint         prop_id,
6660   GValue       *value,
6661   GParamSpec   *pspec G_GNUC_UNUSED)
6662 {
6663   const _ExtendedGDBusPropertyInfo *info;
6664   GVariant *variant;
6665   g_assert (prop_id != 0 && prop_id - 1 < 4);
6666   info = _org_freedesktop_udisks_property_info_pointers[prop_id - 1];
6667   variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (object), info->parent_struct.name);
6668   if (info->use_gvariant)
6669     {
6670       g_value_set_variant (value, variant);
6671     }
6672   else
6673     {
6674       if (variant != NULL)
6675         g_dbus_gvariant_to_gvalue (variant, value);
6676     }
6677   if (variant != NULL)
6678     g_variant_unref (variant);
6679 }
6680
6681 static void
6682 org_freedesktop_udisks_proxy_set_property_cb (GDBusProxy *proxy,
6683   GAsyncResult *res,
6684   gpointer      user_data)
6685 {
6686   const _ExtendedGDBusPropertyInfo *info = user_data;
6687   GError *error;
6688   GVariant *_ret;
6689   error = NULL;
6690   _ret = g_dbus_proxy_call_finish (proxy, res, &error);
6691   if (!_ret)
6692     {
6693       g_warning ("Error setting property '%s' on interface org.freedesktop.UDisks: %s (%s, %d)",
6694                  info->parent_struct.name,
6695                  error->message, g_quark_to_string (error->domain), error->code);
6696       g_error_free (error);
6697     }
6698   else
6699     {
6700       g_variant_unref (_ret);
6701     }
6702 }
6703
6704 static void
6705 org_freedesktop_udisks_proxy_set_property (GObject      *object,
6706   guint         prop_id,
6707   const GValue *value,
6708   GParamSpec   *pspec G_GNUC_UNUSED)
6709 {
6710   const _ExtendedGDBusPropertyInfo *info;
6711   GVariant *variant;
6712   g_assert (prop_id != 0 && prop_id - 1 < 4);
6713   info = _org_freedesktop_udisks_property_info_pointers[prop_id - 1];
6714   variant = g_dbus_gvalue_to_gvariant (value, G_VARIANT_TYPE (info->parent_struct.signature));
6715   g_dbus_proxy_call (G_DBUS_PROXY (object),
6716     "org.freedesktop.DBus.Properties.Set",
6717     g_variant_new ("(ssv)", "org.freedesktop.UDisks", info->parent_struct.name, variant),
6718     G_DBUS_CALL_FLAGS_NONE,
6719     -1,
6720     NULL, (GAsyncReadyCallback) org_freedesktop_udisks_proxy_set_property_cb, (GDBusPropertyInfo *) &info->parent_struct);
6721   g_variant_unref (variant);
6722 }
6723
6724 static void
6725 org_freedesktop_udisks_proxy_g_signal (GDBusProxy *proxy,
6726   const gchar *sender_name G_GNUC_UNUSED,
6727   const gchar *signal_name,
6728   GVariant *parameters)
6729 {
6730   _ExtendedGDBusSignalInfo *info;
6731   GVariantIter iter;
6732   GVariant *child;
6733   GValue *paramv;
6734   gsize num_params;
6735   gsize n;
6736   guint signal_id;
6737   info = (_ExtendedGDBusSignalInfo *) g_dbus_interface_info_lookup_signal ((GDBusInterfaceInfo *) &_org_freedesktop_udisks_interface_info.parent_struct, signal_name);
6738   if (info == NULL)
6739     return;
6740   num_params = g_variant_n_children (parameters);
6741   paramv = g_new0 (GValue, num_params + 1);
6742   g_value_init (&paramv[0], TYPE_ORG_FREEDESKTOP_UDISKS);
6743   g_value_set_object (&paramv[0], proxy);
6744   g_variant_iter_init (&iter, parameters);
6745   n = 1;
6746   while ((child = g_variant_iter_next_value (&iter)) != NULL)
6747     {
6748       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.args[n - 1];
6749       if (arg_info->use_gvariant)
6750         {
6751           g_value_init (&paramv[n], G_TYPE_VARIANT);
6752           g_value_set_variant (&paramv[n], child);
6753           n++;
6754         }
6755       else
6756         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
6757       g_variant_unref (child);
6758     }
6759   signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_FREEDESKTOP_UDISKS);
6760   g_signal_emitv (paramv, signal_id, 0, NULL);
6761   for (n = 0; n < num_params + 1; n++)
6762     g_value_unset (&paramv[n]);
6763   g_free (paramv);
6764 }
6765
6766 static void
6767 org_freedesktop_udisks_proxy_g_properties_changed (GDBusProxy *_proxy,
6768   GVariant *changed_properties,
6769   const gchar *const *invalidated_properties)
6770 {
6771   OrgFreedesktopUDisksProxy *proxy = ORG_FREEDESKTOP_UDISKS_PROXY (_proxy);
6772   guint n;
6773   const gchar *key;
6774   GVariantIter *iter;
6775   _ExtendedGDBusPropertyInfo *info;
6776   g_variant_get (changed_properties, "a{sv}", &iter);
6777   while (g_variant_iter_next (iter, "{&sv}", &key, NULL))
6778     {
6779       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_udisks_interface_info.parent_struct, key);
6780       g_datalist_remove_data (&proxy->priv->qdata, key);
6781       if (info != NULL)
6782         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
6783     }
6784   g_variant_iter_free (iter);
6785   for (n = 0; invalidated_properties[n] != NULL; n++)
6786     {
6787       info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_udisks_interface_info.parent_struct, invalidated_properties[n]);
6788       g_datalist_remove_data (&proxy->priv->qdata, invalidated_properties[n]);
6789       if (info != NULL)
6790         g_object_notify (G_OBJECT (proxy), info->hyphen_name);
6791     }
6792 }
6793
6794 static const gchar *
6795 org_freedesktop_udisks_proxy_get_daemon_version (OrgFreedesktopUDisks *object)
6796 {
6797   OrgFreedesktopUDisksProxy *proxy = ORG_FREEDESKTOP_UDISKS_PROXY (object);
6798   GVariant *variant;
6799   const gchar *value = NULL;
6800   variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "DaemonVersion");
6801   if (variant != NULL)
6802     {
6803       value = g_variant_get_string (variant, NULL);
6804       g_variant_unref (variant);
6805     }
6806   return value;
6807 }
6808
6809 static gboolean
6810 org_freedesktop_udisks_proxy_get_daemon_is_inhibited (OrgFreedesktopUDisks *object)
6811 {
6812   OrgFreedesktopUDisksProxy *proxy = ORG_FREEDESKTOP_UDISKS_PROXY (object);
6813   GVariant *variant;
6814   gboolean value = 0;
6815   variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "DaemonIsInhibited");
6816   if (variant != NULL)
6817     {
6818       value = g_variant_get_boolean (variant);
6819       g_variant_unref (variant);
6820     }
6821   return value;
6822 }
6823
6824 static gboolean
6825 org_freedesktop_udisks_proxy_get_supports_luks_devices (OrgFreedesktopUDisks *object)
6826 {
6827   OrgFreedesktopUDisksProxy *proxy = ORG_FREEDESKTOP_UDISKS_PROXY (object);
6828   GVariant *variant;
6829   gboolean value = 0;
6830   variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "SupportsLuksDevices");
6831   if (variant != NULL)
6832     {
6833       value = g_variant_get_boolean (variant);
6834       g_variant_unref (variant);
6835     }
6836   return value;
6837 }
6838
6839 static GVariant *
6840 org_freedesktop_udisks_proxy_get_known_filesystems (OrgFreedesktopUDisks *object)
6841 {
6842   OrgFreedesktopUDisksProxy *proxy = ORG_FREEDESKTOP_UDISKS_PROXY (object);
6843   GVariant *variant;
6844   GVariant *value = NULL;
6845   variant = g_dbus_proxy_get_cached_property (G_DBUS_PROXY (proxy), "KnownFilesystems");
6846   value = variant;
6847   if (variant != NULL)
6848     g_variant_unref (variant);
6849   return value;
6850 }
6851
6852 static void
6853 org_freedesktop_udisks_proxy_init (OrgFreedesktopUDisksProxy *proxy)
6854 {
6855 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
6856   proxy->priv = org_freedesktop_udisks_proxy_get_instance_private (proxy);
6857 #else
6858   proxy->priv = G_TYPE_INSTANCE_GET_PRIVATE (proxy, TYPE_ORG_FREEDESKTOP_UDISKS_PROXY, OrgFreedesktopUDisksProxyPrivate);
6859 #endif
6860
6861   g_dbus_proxy_set_interface_info (G_DBUS_PROXY (proxy), org_freedesktop_udisks_interface_info ());
6862 }
6863
6864 static void
6865 org_freedesktop_udisks_proxy_class_init (OrgFreedesktopUDisksProxyClass *klass)
6866 {
6867   GObjectClass *gobject_class;
6868   GDBusProxyClass *proxy_class;
6869
6870   gobject_class = G_OBJECT_CLASS (klass);
6871   gobject_class->finalize     = org_freedesktop_udisks_proxy_finalize;
6872   gobject_class->get_property = org_freedesktop_udisks_proxy_get_property;
6873   gobject_class->set_property = org_freedesktop_udisks_proxy_set_property;
6874
6875   proxy_class = G_DBUS_PROXY_CLASS (klass);
6876   proxy_class->g_signal = org_freedesktop_udisks_proxy_g_signal;
6877   proxy_class->g_properties_changed = org_freedesktop_udisks_proxy_g_properties_changed;
6878
6879   org_freedesktop_udisks_override_properties (gobject_class, 1);
6880
6881 #if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
6882   g_type_class_add_private (klass, sizeof (OrgFreedesktopUDisksProxyPrivate));
6883 #endif
6884 }
6885
6886 static void
6887 org_freedesktop_udisks_proxy_iface_init (OrgFreedesktopUDisksIface *iface)
6888 {
6889   iface->get_daemon_version = org_freedesktop_udisks_proxy_get_daemon_version;
6890   iface->get_daemon_is_inhibited = org_freedesktop_udisks_proxy_get_daemon_is_inhibited;
6891   iface->get_supports_luks_devices = org_freedesktop_udisks_proxy_get_supports_luks_devices;
6892   iface->get_known_filesystems = org_freedesktop_udisks_proxy_get_known_filesystems;
6893 }
6894
6895 /**
6896  * org_freedesktop_udisks_proxy_new:
6897  * @connection: A #GDBusConnection.
6898  * @flags: Flags from the #GDBusProxyFlags enumeration.
6899  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
6900  * @object_path: An object path.
6901  * @cancellable: (allow-none): A #GCancellable or %NULL.
6902  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
6903  * @user_data: User data to pass to @callback.
6904  *
6905  * Asynchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks.top_of_page">org.freedesktop.UDisks</link>. See g_dbus_proxy_new() for more details.
6906  *
6907  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
6908  * You can then call org_freedesktop_udisks_proxy_new_finish() to get the result of the operation.
6909  *
6910  * See org_freedesktop_udisks_proxy_new_sync() for the synchronous, blocking version of this constructor.
6911  */
6912 void
6913 org_freedesktop_udisks_proxy_new (
6914     GDBusConnection     *connection,
6915     GDBusProxyFlags      flags,
6916     const gchar         *name,
6917     const gchar         *object_path,
6918     GCancellable        *cancellable,
6919     GAsyncReadyCallback  callback,
6920     gpointer             user_data)
6921 {
6922   g_async_initable_new_async (TYPE_ORG_FREEDESKTOP_UDISKS_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.UDisks", NULL);
6923 }
6924
6925 /**
6926  * org_freedesktop_udisks_proxy_new_finish:
6927  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_proxy_new().
6928  * @error: Return location for error or %NULL
6929  *
6930  * Finishes an operation started with org_freedesktop_udisks_proxy_new().
6931  *
6932  * Returns: (transfer full) (type OrgFreedesktopUDisksProxy): The constructed proxy object or %NULL if @error is set.
6933  */
6934 OrgFreedesktopUDisks *
6935 org_freedesktop_udisks_proxy_new_finish (
6936     GAsyncResult        *res,
6937     GError             **error)
6938 {
6939   GObject *ret;
6940   GObject *source_object;
6941   source_object = g_async_result_get_source_object (res);
6942   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
6943   g_object_unref (source_object);
6944   if (ret != NULL)
6945     return ORG_FREEDESKTOP_UDISKS (ret);
6946   else
6947     return NULL;
6948 }
6949
6950 /**
6951  * org_freedesktop_udisks_proxy_new_sync:
6952  * @connection: A #GDBusConnection.
6953  * @flags: Flags from the #GDBusProxyFlags enumeration.
6954  * @name: (allow-none): A bus name (well-known or unique) or %NULL if @connection is not a message bus connection.
6955  * @object_path: An object path.
6956  * @cancellable: (allow-none): A #GCancellable or %NULL.
6957  * @error: Return location for error or %NULL
6958  *
6959  * Synchronously creates a proxy for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks.top_of_page">org.freedesktop.UDisks</link>. See g_dbus_proxy_new_sync() for more details.
6960  *
6961  * The calling thread is blocked until a reply is received.
6962  *
6963  * See org_freedesktop_udisks_proxy_new() for the asynchronous version of this constructor.
6964  *
6965  * Returns: (transfer full) (type OrgFreedesktopUDisksProxy): The constructed proxy object or %NULL if @error is set.
6966  */
6967 OrgFreedesktopUDisks *
6968 org_freedesktop_udisks_proxy_new_sync (
6969     GDBusConnection     *connection,
6970     GDBusProxyFlags      flags,
6971     const gchar         *name,
6972     const gchar         *object_path,
6973     GCancellable        *cancellable,
6974     GError             **error)
6975 {
6976   GInitable *ret;
6977   ret = g_initable_new (TYPE_ORG_FREEDESKTOP_UDISKS_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-connection", connection, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks", NULL);
6978   if (ret != NULL)
6979     return ORG_FREEDESKTOP_UDISKS (ret);
6980   else
6981     return NULL;
6982 }
6983
6984
6985 /**
6986  * org_freedesktop_udisks_proxy_new_for_bus:
6987  * @bus_type: A #GBusType.
6988  * @flags: Flags from the #GDBusProxyFlags enumeration.
6989  * @name: A bus name (well-known or unique).
6990  * @object_path: An object path.
6991  * @cancellable: (allow-none): A #GCancellable or %NULL.
6992  * @callback: A #GAsyncReadyCallback to call when the request is satisfied.
6993  * @user_data: User data to pass to @callback.
6994  *
6995  * Like org_freedesktop_udisks_proxy_new() but takes a #GBusType instead of a #GDBusConnection.
6996  *
6997  * When the operation is finished, @callback will be invoked in the <link linkend="g-main-context-push-thread-default">thread-default main loop</link> of the thread you are calling this method from.
6998  * You can then call org_freedesktop_udisks_proxy_new_for_bus_finish() to get the result of the operation.
6999  *
7000  * See org_freedesktop_udisks_proxy_new_for_bus_sync() for the synchronous, blocking version of this constructor.
7001  */
7002 void
7003 org_freedesktop_udisks_proxy_new_for_bus (
7004     GBusType             bus_type,
7005     GDBusProxyFlags      flags,
7006     const gchar         *name,
7007     const gchar         *object_path,
7008     GCancellable        *cancellable,
7009     GAsyncReadyCallback  callback,
7010     gpointer             user_data)
7011 {
7012   g_async_initable_new_async (TYPE_ORG_FREEDESKTOP_UDISKS_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.UDisks", NULL);
7013 }
7014
7015 /**
7016  * org_freedesktop_udisks_proxy_new_for_bus_finish:
7017  * @res: The #GAsyncResult obtained from the #GAsyncReadyCallback passed to org_freedesktop_udisks_proxy_new_for_bus().
7018  * @error: Return location for error or %NULL
7019  *
7020  * Finishes an operation started with org_freedesktop_udisks_proxy_new_for_bus().
7021  *
7022  * Returns: (transfer full) (type OrgFreedesktopUDisksProxy): The constructed proxy object or %NULL if @error is set.
7023  */
7024 OrgFreedesktopUDisks *
7025 org_freedesktop_udisks_proxy_new_for_bus_finish (
7026     GAsyncResult        *res,
7027     GError             **error)
7028 {
7029   GObject *ret;
7030   GObject *source_object;
7031   source_object = g_async_result_get_source_object (res);
7032   ret = g_async_initable_new_finish (G_ASYNC_INITABLE (source_object), res, error);
7033   g_object_unref (source_object);
7034   if (ret != NULL)
7035     return ORG_FREEDESKTOP_UDISKS (ret);
7036   else
7037     return NULL;
7038 }
7039
7040 /**
7041  * org_freedesktop_udisks_proxy_new_for_bus_sync:
7042  * @bus_type: A #GBusType.
7043  * @flags: Flags from the #GDBusProxyFlags enumeration.
7044  * @name: A bus name (well-known or unique).
7045  * @object_path: An object path.
7046  * @cancellable: (allow-none): A #GCancellable or %NULL.
7047  * @error: Return location for error or %NULL
7048  *
7049  * Like org_freedesktop_udisks_proxy_new_sync() but takes a #GBusType instead of a #GDBusConnection.
7050  *
7051  * The calling thread is blocked until a reply is received.
7052  *
7053  * See org_freedesktop_udisks_proxy_new_for_bus() for the asynchronous version of this constructor.
7054  *
7055  * Returns: (transfer full) (type OrgFreedesktopUDisksProxy): The constructed proxy object or %NULL if @error is set.
7056  */
7057 OrgFreedesktopUDisks *
7058 org_freedesktop_udisks_proxy_new_for_bus_sync (
7059     GBusType             bus_type,
7060     GDBusProxyFlags      flags,
7061     const gchar         *name,
7062     const gchar         *object_path,
7063     GCancellable        *cancellable,
7064     GError             **error)
7065 {
7066   GInitable *ret;
7067   ret = g_initable_new (TYPE_ORG_FREEDESKTOP_UDISKS_PROXY, cancellable, error, "g-flags", flags, "g-name", name, "g-bus-type", bus_type, "g-object-path", object_path, "g-interface-name", "org.freedesktop.UDisks", NULL);
7068   if (ret != NULL)
7069     return ORG_FREEDESKTOP_UDISKS (ret);
7070   else
7071     return NULL;
7072 }
7073
7074
7075 /* ------------------------------------------------------------------------ */
7076
7077 /**
7078  * OrgFreedesktopUDisksSkeleton:
7079  *
7080  * The #OrgFreedesktopUDisksSkeleton structure contains only private data and should only be accessed using the provided API.
7081  */
7082
7083 /**
7084  * OrgFreedesktopUDisksSkeletonClass:
7085  * @parent_class: The parent class.
7086  *
7087  * Class structure for #OrgFreedesktopUDisksSkeleton.
7088  */
7089
7090 struct _OrgFreedesktopUDisksSkeletonPrivate
7091 {
7092   GValue *properties;
7093   GList *changed_properties;
7094   GSource *changed_properties_idle_source;
7095   GMainContext *context;
7096   GMutex lock;
7097 };
7098
7099 static void
7100 _org_freedesktop_udisks_skeleton_handle_method_call (
7101   GDBusConnection *connection G_GNUC_UNUSED,
7102   const gchar *sender G_GNUC_UNUSED,
7103   const gchar *object_path G_GNUC_UNUSED,
7104   const gchar *interface_name,
7105   const gchar *method_name,
7106   GVariant *parameters,
7107   GDBusMethodInvocation *invocation,
7108   gpointer user_data)
7109 {
7110   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (user_data);
7111   _ExtendedGDBusMethodInfo *info;
7112   GVariantIter iter;
7113   GVariant *child;
7114   GValue *paramv;
7115   gsize num_params;
7116   guint num_extra;
7117   gsize n;
7118   guint signal_id;
7119   GValue return_value = G_VALUE_INIT;
7120   info = (_ExtendedGDBusMethodInfo *) g_dbus_method_invocation_get_method_info (invocation);
7121   g_assert (info != NULL);
7122   num_params = g_variant_n_children (parameters);
7123   num_extra = info->pass_fdlist ? 3 : 2;  paramv = g_new0 (GValue, num_params + num_extra);
7124   n = 0;
7125   g_value_init (&paramv[n], TYPE_ORG_FREEDESKTOP_UDISKS);
7126   g_value_set_object (&paramv[n++], skeleton);
7127   g_value_init (&paramv[n], G_TYPE_DBUS_METHOD_INVOCATION);
7128   g_value_set_object (&paramv[n++], invocation);
7129   if (info->pass_fdlist)
7130     {
7131 #ifdef G_OS_UNIX
7132       g_value_init (&paramv[n], G_TYPE_UNIX_FD_LIST);
7133       g_value_set_object (&paramv[n++], g_dbus_message_get_unix_fd_list (g_dbus_method_invocation_get_message (invocation)));
7134 #else
7135       g_assert_not_reached ();
7136 #endif
7137     }
7138   g_variant_iter_init (&iter, parameters);
7139   while ((child = g_variant_iter_next_value (&iter)) != NULL)
7140     {
7141       _ExtendedGDBusArgInfo *arg_info = (_ExtendedGDBusArgInfo *) info->parent_struct.in_args[n - num_extra];
7142       if (arg_info->use_gvariant)
7143         {
7144           g_value_init (&paramv[n], G_TYPE_VARIANT);
7145           g_value_set_variant (&paramv[n], child);
7146           n++;
7147         }
7148       else
7149         g_dbus_gvariant_to_gvalue (child, &paramv[n++]);
7150       g_variant_unref (child);
7151     }
7152   signal_id = g_signal_lookup (info->signal_name, TYPE_ORG_FREEDESKTOP_UDISKS);
7153   g_value_init (&return_value, G_TYPE_BOOLEAN);
7154   g_signal_emitv (paramv, signal_id, 0, &return_value);
7155   if (!g_value_get_boolean (&return_value))
7156     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);
7157   g_value_unset (&return_value);
7158   for (n = 0; n < num_params + num_extra; n++)
7159     g_value_unset (&paramv[n]);
7160   g_free (paramv);
7161 }
7162
7163 static GVariant *
7164 _org_freedesktop_udisks_skeleton_handle_get_property (
7165   GDBusConnection *connection G_GNUC_UNUSED,
7166   const gchar *sender G_GNUC_UNUSED,
7167   const gchar *object_path G_GNUC_UNUSED,
7168   const gchar *interface_name G_GNUC_UNUSED,
7169   const gchar *property_name,
7170   GError **error,
7171   gpointer user_data)
7172 {
7173   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (user_data);
7174   GValue value = G_VALUE_INIT;
7175   GParamSpec *pspec;
7176   _ExtendedGDBusPropertyInfo *info;
7177   GVariant *ret;
7178   ret = NULL;
7179   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_udisks_interface_info.parent_struct, property_name);
7180   g_assert (info != NULL);
7181   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
7182   if (pspec == NULL)
7183     {
7184       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
7185     }
7186   else
7187     {
7188       g_value_init (&value, pspec->value_type);
7189       g_object_get_property (G_OBJECT (skeleton), info->hyphen_name, &value);
7190       ret = g_dbus_gvalue_to_gvariant (&value, G_VARIANT_TYPE (info->parent_struct.signature));
7191       g_value_unset (&value);
7192     }
7193   return ret;
7194 }
7195
7196 static gboolean
7197 _org_freedesktop_udisks_skeleton_handle_set_property (
7198   GDBusConnection *connection G_GNUC_UNUSED,
7199   const gchar *sender G_GNUC_UNUSED,
7200   const gchar *object_path G_GNUC_UNUSED,
7201   const gchar *interface_name G_GNUC_UNUSED,
7202   const gchar *property_name,
7203   GVariant *variant,
7204   GError **error,
7205   gpointer user_data)
7206 {
7207   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (user_data);
7208   GValue value = G_VALUE_INIT;
7209   GParamSpec *pspec;
7210   _ExtendedGDBusPropertyInfo *info;
7211   gboolean ret;
7212   ret = FALSE;
7213   info = (_ExtendedGDBusPropertyInfo *) g_dbus_interface_info_lookup_property ((GDBusInterfaceInfo *) &_org_freedesktop_udisks_interface_info.parent_struct, property_name);
7214   g_assert (info != NULL);
7215   pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (skeleton), info->hyphen_name);
7216   if (pspec == NULL)
7217     {
7218       g_set_error (error, G_DBUS_ERROR, G_DBUS_ERROR_INVALID_ARGS, "No property with name %s", property_name);
7219     }
7220   else
7221     {
7222       if (info->use_gvariant)
7223         g_value_set_variant (&value, variant);
7224       else
7225         g_dbus_gvariant_to_gvalue (variant, &value);
7226       g_object_set_property (G_OBJECT (skeleton), info->hyphen_name, &value);
7227       g_value_unset (&value);
7228       ret = TRUE;
7229     }
7230   return ret;
7231 }
7232
7233 static const GDBusInterfaceVTable _org_freedesktop_udisks_skeleton_vtable =
7234 {
7235   _org_freedesktop_udisks_skeleton_handle_method_call,
7236   _org_freedesktop_udisks_skeleton_handle_get_property,
7237   _org_freedesktop_udisks_skeleton_handle_set_property,
7238   {NULL}
7239 };
7240
7241 static GDBusInterfaceInfo *
7242 org_freedesktop_udisks_skeleton_dbus_interface_get_info (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
7243 {
7244   return org_freedesktop_udisks_interface_info ();
7245 }
7246
7247 static GDBusInterfaceVTable *
7248 org_freedesktop_udisks_skeleton_dbus_interface_get_vtable (GDBusInterfaceSkeleton *skeleton G_GNUC_UNUSED)
7249 {
7250   return (GDBusInterfaceVTable *) &_org_freedesktop_udisks_skeleton_vtable;
7251 }
7252
7253 static GVariant *
7254 org_freedesktop_udisks_skeleton_dbus_interface_get_properties (GDBusInterfaceSkeleton *_skeleton)
7255 {
7256   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (_skeleton);
7257
7258   GVariantBuilder builder;
7259   guint n;
7260   g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
7261   if (_org_freedesktop_udisks_interface_info.parent_struct.properties == NULL)
7262     goto out;
7263   for (n = 0; _org_freedesktop_udisks_interface_info.parent_struct.properties[n] != NULL; n++)
7264     {
7265       GDBusPropertyInfo *info = _org_freedesktop_udisks_interface_info.parent_struct.properties[n];
7266       if (info->flags & G_DBUS_PROPERTY_INFO_FLAGS_READABLE)
7267         {
7268           GVariant *value;
7269           value = _org_freedesktop_udisks_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.UDisks", info->name, NULL, skeleton);
7270           if (value != NULL)
7271             {
7272               g_variant_take_ref (value);
7273               g_variant_builder_add (&builder, "{sv}", info->name, value);
7274               g_variant_unref (value);
7275             }
7276         }
7277     }
7278 out:
7279   return g_variant_builder_end (&builder);
7280 }
7281
7282 static gboolean _org_freedesktop_udisks_emit_changed (gpointer user_data);
7283
7284 static void
7285 org_freedesktop_udisks_skeleton_dbus_interface_flush (GDBusInterfaceSkeleton *_skeleton)
7286 {
7287   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (_skeleton);
7288   gboolean emit_changed = FALSE;
7289
7290   g_mutex_lock (&skeleton->priv->lock);
7291   if (skeleton->priv->changed_properties_idle_source != NULL)
7292     {
7293       g_source_destroy (skeleton->priv->changed_properties_idle_source);
7294       skeleton->priv->changed_properties_idle_source = NULL;
7295       emit_changed = TRUE;
7296     }
7297   g_mutex_unlock (&skeleton->priv->lock);
7298
7299   if (emit_changed)
7300     _org_freedesktop_udisks_emit_changed (skeleton);
7301 }
7302
7303 static void
7304 _org_freedesktop_udisks_on_signal_device_added (
7305     OrgFreedesktopUDisks *object,
7306     const gchar *arg_device)
7307 {
7308   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7309
7310   GList      *connections, *l;
7311   GVariant   *signal_variant;
7312   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7313
7314   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
7315                    arg_device));
7316   for (l = connections; l != NULL; l = l->next)
7317     {
7318       GDBusConnection *connection = l->data;
7319       g_dbus_connection_emit_signal (connection,
7320         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks", "DeviceAdded",
7321         signal_variant, NULL);
7322     }
7323   g_variant_unref (signal_variant);
7324   g_list_free_full (connections, g_object_unref);
7325 }
7326
7327 static void
7328 _org_freedesktop_udisks_on_signal_device_removed (
7329     OrgFreedesktopUDisks *object,
7330     const gchar *arg_device)
7331 {
7332   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7333
7334   GList      *connections, *l;
7335   GVariant   *signal_variant;
7336   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7337
7338   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
7339                    arg_device));
7340   for (l = connections; l != NULL; l = l->next)
7341     {
7342       GDBusConnection *connection = l->data;
7343       g_dbus_connection_emit_signal (connection,
7344         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks", "DeviceRemoved",
7345         signal_variant, NULL);
7346     }
7347   g_variant_unref (signal_variant);
7348   g_list_free_full (connections, g_object_unref);
7349 }
7350
7351 static void
7352 _org_freedesktop_udisks_on_signal_device_changed (
7353     OrgFreedesktopUDisks *object,
7354     const gchar *arg_device)
7355 {
7356   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7357
7358   GList      *connections, *l;
7359   GVariant   *signal_variant;
7360   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7361
7362   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
7363                    arg_device));
7364   for (l = connections; l != NULL; l = l->next)
7365     {
7366       GDBusConnection *connection = l->data;
7367       g_dbus_connection_emit_signal (connection,
7368         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks", "DeviceChanged",
7369         signal_variant, NULL);
7370     }
7371   g_variant_unref (signal_variant);
7372   g_list_free_full (connections, g_object_unref);
7373 }
7374
7375 static void
7376 _org_freedesktop_udisks_on_signal_device_job_changed (
7377     OrgFreedesktopUDisks *object,
7378     const gchar *arg_device,
7379     gboolean arg_job_in_progress,
7380     gboolean arg_job_is_cancellable,
7381     const gchar *arg_job_id,
7382     gint arg_job_num_tasks,
7383     gint arg_job_cur_task,
7384     const gchar *arg_job_cur_task_id,
7385     gdouble arg_job_cur_task_percentage)
7386 {
7387   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7388
7389   GList      *connections, *l;
7390   GVariant   *signal_variant;
7391   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7392
7393   signal_variant = g_variant_ref_sink (g_variant_new ("(obbsiisd)",
7394                    arg_device,
7395                    arg_job_in_progress,
7396                    arg_job_is_cancellable,
7397                    arg_job_id,
7398                    arg_job_num_tasks,
7399                    arg_job_cur_task,
7400                    arg_job_cur_task_id,
7401                    arg_job_cur_task_percentage));
7402   for (l = connections; l != NULL; l = l->next)
7403     {
7404       GDBusConnection *connection = l->data;
7405       g_dbus_connection_emit_signal (connection,
7406         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks", "DeviceJobChanged",
7407         signal_variant, NULL);
7408     }
7409   g_variant_unref (signal_variant);
7410   g_list_free_full (connections, g_object_unref);
7411 }
7412
7413 static void
7414 _org_freedesktop_udisks_on_signal_adapter_added (
7415     OrgFreedesktopUDisks *object,
7416     const gchar *arg_adapter)
7417 {
7418   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7419
7420   GList      *connections, *l;
7421   GVariant   *signal_variant;
7422   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7423
7424   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
7425                    arg_adapter));
7426   for (l = connections; l != NULL; l = l->next)
7427     {
7428       GDBusConnection *connection = l->data;
7429       g_dbus_connection_emit_signal (connection,
7430         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks", "AdapterAdded",
7431         signal_variant, NULL);
7432     }
7433   g_variant_unref (signal_variant);
7434   g_list_free_full (connections, g_object_unref);
7435 }
7436
7437 static void
7438 _org_freedesktop_udisks_on_signal_adapter_removed (
7439     OrgFreedesktopUDisks *object,
7440     const gchar *arg_adapter)
7441 {
7442   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7443
7444   GList      *connections, *l;
7445   GVariant   *signal_variant;
7446   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7447
7448   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
7449                    arg_adapter));
7450   for (l = connections; l != NULL; l = l->next)
7451     {
7452       GDBusConnection *connection = l->data;
7453       g_dbus_connection_emit_signal (connection,
7454         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks", "AdapterRemoved",
7455         signal_variant, NULL);
7456     }
7457   g_variant_unref (signal_variant);
7458   g_list_free_full (connections, g_object_unref);
7459 }
7460
7461 static void
7462 _org_freedesktop_udisks_on_signal_adapter_changed (
7463     OrgFreedesktopUDisks *object,
7464     const gchar *arg_adapter)
7465 {
7466   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7467
7468   GList      *connections, *l;
7469   GVariant   *signal_variant;
7470   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7471
7472   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
7473                    arg_adapter));
7474   for (l = connections; l != NULL; l = l->next)
7475     {
7476       GDBusConnection *connection = l->data;
7477       g_dbus_connection_emit_signal (connection,
7478         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks", "AdapterChanged",
7479         signal_variant, NULL);
7480     }
7481   g_variant_unref (signal_variant);
7482   g_list_free_full (connections, g_object_unref);
7483 }
7484
7485 static void
7486 _org_freedesktop_udisks_on_signal_expander_added (
7487     OrgFreedesktopUDisks *object,
7488     const gchar *arg_expander)
7489 {
7490   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7491
7492   GList      *connections, *l;
7493   GVariant   *signal_variant;
7494   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7495
7496   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
7497                    arg_expander));
7498   for (l = connections; l != NULL; l = l->next)
7499     {
7500       GDBusConnection *connection = l->data;
7501       g_dbus_connection_emit_signal (connection,
7502         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks", "ExpanderAdded",
7503         signal_variant, NULL);
7504     }
7505   g_variant_unref (signal_variant);
7506   g_list_free_full (connections, g_object_unref);
7507 }
7508
7509 static void
7510 _org_freedesktop_udisks_on_signal_expander_removed (
7511     OrgFreedesktopUDisks *object,
7512     const gchar *arg_expander)
7513 {
7514   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7515
7516   GList      *connections, *l;
7517   GVariant   *signal_variant;
7518   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7519
7520   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
7521                    arg_expander));
7522   for (l = connections; l != NULL; l = l->next)
7523     {
7524       GDBusConnection *connection = l->data;
7525       g_dbus_connection_emit_signal (connection,
7526         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks", "ExpanderRemoved",
7527         signal_variant, NULL);
7528     }
7529   g_variant_unref (signal_variant);
7530   g_list_free_full (connections, g_object_unref);
7531 }
7532
7533 static void
7534 _org_freedesktop_udisks_on_signal_expander_changed (
7535     OrgFreedesktopUDisks *object,
7536     const gchar *arg_expander)
7537 {
7538   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7539
7540   GList      *connections, *l;
7541   GVariant   *signal_variant;
7542   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7543
7544   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
7545                    arg_expander));
7546   for (l = connections; l != NULL; l = l->next)
7547     {
7548       GDBusConnection *connection = l->data;
7549       g_dbus_connection_emit_signal (connection,
7550         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks", "ExpanderChanged",
7551         signal_variant, NULL);
7552     }
7553   g_variant_unref (signal_variant);
7554   g_list_free_full (connections, g_object_unref);
7555 }
7556
7557 static void
7558 _org_freedesktop_udisks_on_signal_port_added (
7559     OrgFreedesktopUDisks *object,
7560     const gchar *arg_port)
7561 {
7562   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7563
7564   GList      *connections, *l;
7565   GVariant   *signal_variant;
7566   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7567
7568   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
7569                    arg_port));
7570   for (l = connections; l != NULL; l = l->next)
7571     {
7572       GDBusConnection *connection = l->data;
7573       g_dbus_connection_emit_signal (connection,
7574         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks", "PortAdded",
7575         signal_variant, NULL);
7576     }
7577   g_variant_unref (signal_variant);
7578   g_list_free_full (connections, g_object_unref);
7579 }
7580
7581 static void
7582 _org_freedesktop_udisks_on_signal_port_removed (
7583     OrgFreedesktopUDisks *object,
7584     const gchar *arg_port)
7585 {
7586   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7587
7588   GList      *connections, *l;
7589   GVariant   *signal_variant;
7590   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7591
7592   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
7593                    arg_port));
7594   for (l = connections; l != NULL; l = l->next)
7595     {
7596       GDBusConnection *connection = l->data;
7597       g_dbus_connection_emit_signal (connection,
7598         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks", "PortRemoved",
7599         signal_variant, NULL);
7600     }
7601   g_variant_unref (signal_variant);
7602   g_list_free_full (connections, g_object_unref);
7603 }
7604
7605 static void
7606 _org_freedesktop_udisks_on_signal_port_changed (
7607     OrgFreedesktopUDisks *object,
7608     const gchar *arg_port)
7609 {
7610   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7611
7612   GList      *connections, *l;
7613   GVariant   *signal_variant;
7614   connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7615
7616   signal_variant = g_variant_ref_sink (g_variant_new ("(o)",
7617                    arg_port));
7618   for (l = connections; l != NULL; l = l->next)
7619     {
7620       GDBusConnection *connection = l->data;
7621       g_dbus_connection_emit_signal (connection,
7622         NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)), "org.freedesktop.UDisks", "PortChanged",
7623         signal_variant, NULL);
7624     }
7625   g_variant_unref (signal_variant);
7626   g_list_free_full (connections, g_object_unref);
7627 }
7628
7629 static void org_freedesktop_udisks_skeleton_iface_init (OrgFreedesktopUDisksIface *iface);
7630 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
7631 G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopUDisksSkeleton, org_freedesktop_udisks_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
7632                          G_ADD_PRIVATE (OrgFreedesktopUDisksSkeleton)
7633                          G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_UDISKS, org_freedesktop_udisks_skeleton_iface_init));
7634
7635 #else
7636 G_DEFINE_TYPE_WITH_CODE (OrgFreedesktopUDisksSkeleton, org_freedesktop_udisks_skeleton, G_TYPE_DBUS_INTERFACE_SKELETON,
7637                          G_IMPLEMENT_INTERFACE (TYPE_ORG_FREEDESKTOP_UDISKS, org_freedesktop_udisks_skeleton_iface_init));
7638
7639 #endif
7640 static void
7641 org_freedesktop_udisks_skeleton_finalize (GObject *object)
7642 {
7643   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7644   guint n;
7645   for (n = 0; n < 4; n++)
7646     g_value_unset (&skeleton->priv->properties[n]);
7647   g_free (skeleton->priv->properties);
7648   g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
7649   if (skeleton->priv->changed_properties_idle_source != NULL)
7650     g_source_destroy (skeleton->priv->changed_properties_idle_source);
7651   g_main_context_unref (skeleton->priv->context);
7652   g_mutex_clear (&skeleton->priv->lock);
7653   G_OBJECT_CLASS (org_freedesktop_udisks_skeleton_parent_class)->finalize (object);
7654 }
7655
7656 static void
7657 org_freedesktop_udisks_skeleton_get_property (GObject      *object,
7658   guint         prop_id,
7659   GValue       *value,
7660   GParamSpec   *pspec G_GNUC_UNUSED)
7661 {
7662   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7663   g_assert (prop_id != 0 && prop_id - 1 < 4);
7664   g_mutex_lock (&skeleton->priv->lock);
7665   g_value_copy (&skeleton->priv->properties[prop_id - 1], value);
7666   g_mutex_unlock (&skeleton->priv->lock);
7667 }
7668
7669 static gboolean
7670 _org_freedesktop_udisks_emit_changed (gpointer user_data)
7671 {
7672   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (user_data);
7673   GList *l;
7674   GVariantBuilder builder;
7675   GVariantBuilder invalidated_builder;
7676   guint num_changes;
7677
7678   g_mutex_lock (&skeleton->priv->lock);
7679   g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
7680   g_variant_builder_init (&invalidated_builder, G_VARIANT_TYPE ("as"));
7681   for (l = skeleton->priv->changed_properties, num_changes = 0; l != NULL; l = l->next)
7682     {
7683       ChangedProperty *cp = l->data;
7684       GVariant *variant;
7685       const GValue *cur_value;
7686
7687       cur_value = &skeleton->priv->properties[cp->prop_id - 1];
7688       if (!_g_value_equal (cur_value, &cp->orig_value))
7689         {
7690           variant = g_dbus_gvalue_to_gvariant (cur_value, G_VARIANT_TYPE (cp->info->parent_struct.signature));
7691           g_variant_builder_add (&builder, "{sv}", cp->info->parent_struct.name, variant);
7692           g_variant_unref (variant);
7693           num_changes++;
7694         }
7695     }
7696   if (num_changes > 0)
7697     {
7698       GList *connections, *ll;
7699       GVariant *signal_variant;
7700       signal_variant = g_variant_ref_sink (g_variant_new ("(sa{sv}as)", "org.freedesktop.UDisks",
7701                                            &builder, &invalidated_builder));
7702       connections = g_dbus_interface_skeleton_get_connections (G_DBUS_INTERFACE_SKELETON (skeleton));
7703       for (ll = connections; ll != NULL; ll = ll->next)
7704         {
7705           GDBusConnection *connection = ll->data;
7706
7707           g_dbus_connection_emit_signal (connection,
7708                                          NULL, g_dbus_interface_skeleton_get_object_path (G_DBUS_INTERFACE_SKELETON (skeleton)),
7709                                          "org.freedesktop.DBus.Properties",
7710                                          "PropertiesChanged",
7711                                          signal_variant,
7712                                          NULL);
7713         }
7714       g_variant_unref (signal_variant);
7715       g_list_free_full (connections, g_object_unref);
7716     }
7717   else
7718     {
7719       g_variant_builder_clear (&builder);
7720       g_variant_builder_clear (&invalidated_builder);
7721     }
7722   g_list_free_full (skeleton->priv->changed_properties, (GDestroyNotify) _changed_property_free);
7723   skeleton->priv->changed_properties = NULL;
7724   skeleton->priv->changed_properties_idle_source = NULL;
7725   g_mutex_unlock (&skeleton->priv->lock);
7726   return FALSE;
7727 }
7728
7729 static void
7730 _org_freedesktop_udisks_schedule_emit_changed (OrgFreedesktopUDisksSkeleton *skeleton, const _ExtendedGDBusPropertyInfo *info, guint prop_id, const GValue *orig_value)
7731 {
7732   ChangedProperty *cp;
7733   GList *l;
7734   cp = NULL;
7735   for (l = skeleton->priv->changed_properties; l != NULL; l = l->next)
7736     {
7737       ChangedProperty *i_cp = l->data;
7738       if (i_cp->info == info)
7739         {
7740           cp = i_cp;
7741           break;
7742         }
7743     }
7744   if (cp == NULL)
7745     {
7746       cp = g_new0 (ChangedProperty, 1);
7747       cp->prop_id = prop_id;
7748       cp->info = info;
7749       skeleton->priv->changed_properties = g_list_prepend (skeleton->priv->changed_properties, cp);
7750       g_value_init (&cp->orig_value, G_VALUE_TYPE (orig_value));
7751       g_value_copy (orig_value, &cp->orig_value);
7752     }
7753 }
7754
7755 static void
7756 org_freedesktop_udisks_skeleton_notify (GObject      *object,
7757   GParamSpec *pspec G_GNUC_UNUSED)
7758 {
7759   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7760   g_mutex_lock (&skeleton->priv->lock);
7761   if (skeleton->priv->changed_properties != NULL &&
7762       skeleton->priv->changed_properties_idle_source == NULL)
7763     {
7764       skeleton->priv->changed_properties_idle_source = g_idle_source_new ();
7765       g_source_set_priority (skeleton->priv->changed_properties_idle_source, G_PRIORITY_DEFAULT);
7766       g_source_set_callback (skeleton->priv->changed_properties_idle_source, _org_freedesktop_udisks_emit_changed, g_object_ref (skeleton), (GDestroyNotify) g_object_unref);
7767       g_source_set_name (skeleton->priv->changed_properties_idle_source, "[generated] _org_freedesktop_udisks_emit_changed");
7768       g_source_attach (skeleton->priv->changed_properties_idle_source, skeleton->priv->context);
7769       g_source_unref (skeleton->priv->changed_properties_idle_source);
7770     }
7771   g_mutex_unlock (&skeleton->priv->lock);
7772 }
7773
7774 static void
7775 org_freedesktop_udisks_skeleton_set_property (GObject      *object,
7776   guint         prop_id,
7777   const GValue *value,
7778   GParamSpec   *pspec)
7779 {
7780   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7781   g_assert (prop_id != 0 && prop_id - 1 < 4);
7782   g_mutex_lock (&skeleton->priv->lock);
7783   g_object_freeze_notify (object);
7784   if (!_g_value_equal (value, &skeleton->priv->properties[prop_id - 1]))
7785     {
7786       if (g_dbus_interface_skeleton_get_connection (G_DBUS_INTERFACE_SKELETON (skeleton)) != NULL)
7787         _org_freedesktop_udisks_schedule_emit_changed (skeleton, _org_freedesktop_udisks_property_info_pointers[prop_id - 1], prop_id, &skeleton->priv->properties[prop_id - 1]);
7788       g_value_copy (value, &skeleton->priv->properties[prop_id - 1]);
7789       g_object_notify_by_pspec (object, pspec);
7790     }
7791   g_mutex_unlock (&skeleton->priv->lock);
7792   g_object_thaw_notify (object);
7793 }
7794
7795 static void
7796 org_freedesktop_udisks_skeleton_init (OrgFreedesktopUDisksSkeleton *skeleton)
7797 {
7798 #if GLIB_VERSION_MAX_ALLOWED >= GLIB_VERSION_2_38
7799   skeleton->priv = org_freedesktop_udisks_skeleton_get_instance_private (skeleton);
7800 #else
7801   skeleton->priv = G_TYPE_INSTANCE_GET_PRIVATE (skeleton, TYPE_ORG_FREEDESKTOP_UDISKS_SKELETON, OrgFreedesktopUDisksSkeletonPrivate);
7802 #endif
7803
7804   g_mutex_init (&skeleton->priv->lock);
7805   skeleton->priv->context = g_main_context_ref_thread_default ();
7806   skeleton->priv->properties = g_new0 (GValue, 4);
7807   g_value_init (&skeleton->priv->properties[0], G_TYPE_STRING);
7808   g_value_init (&skeleton->priv->properties[1], G_TYPE_BOOLEAN);
7809   g_value_init (&skeleton->priv->properties[2], G_TYPE_BOOLEAN);
7810   g_value_init (&skeleton->priv->properties[3], G_TYPE_VARIANT);
7811 }
7812
7813 static const gchar *
7814 org_freedesktop_udisks_skeleton_get_daemon_version (OrgFreedesktopUDisks *object)
7815 {
7816   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7817   const gchar *value;
7818   g_mutex_lock (&skeleton->priv->lock);
7819   value = g_value_get_string (&(skeleton->priv->properties[0]));
7820   g_mutex_unlock (&skeleton->priv->lock);
7821   return value;
7822 }
7823
7824 static gboolean
7825 org_freedesktop_udisks_skeleton_get_daemon_is_inhibited (OrgFreedesktopUDisks *object)
7826 {
7827   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7828   gboolean value;
7829   g_mutex_lock (&skeleton->priv->lock);
7830   value = g_value_get_boolean (&(skeleton->priv->properties[1]));
7831   g_mutex_unlock (&skeleton->priv->lock);
7832   return value;
7833 }
7834
7835 static gboolean
7836 org_freedesktop_udisks_skeleton_get_supports_luks_devices (OrgFreedesktopUDisks *object)
7837 {
7838   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7839   gboolean value;
7840   g_mutex_lock (&skeleton->priv->lock);
7841   value = g_value_get_boolean (&(skeleton->priv->properties[2]));
7842   g_mutex_unlock (&skeleton->priv->lock);
7843   return value;
7844 }
7845
7846 static GVariant *
7847 org_freedesktop_udisks_skeleton_get_known_filesystems (OrgFreedesktopUDisks *object)
7848 {
7849   OrgFreedesktopUDisksSkeleton *skeleton = ORG_FREEDESKTOP_UDISKS_SKELETON (object);
7850   GVariant *value;
7851   g_mutex_lock (&skeleton->priv->lock);
7852   value = g_value_get_variant (&(skeleton->priv->properties[3]));
7853   g_mutex_unlock (&skeleton->priv->lock);
7854   return value;
7855 }
7856
7857 static void
7858 org_freedesktop_udisks_skeleton_class_init (OrgFreedesktopUDisksSkeletonClass *klass)
7859 {
7860   GObjectClass *gobject_class;
7861   GDBusInterfaceSkeletonClass *skeleton_class;
7862
7863   gobject_class = G_OBJECT_CLASS (klass);
7864   gobject_class->finalize = org_freedesktop_udisks_skeleton_finalize;
7865   gobject_class->get_property = org_freedesktop_udisks_skeleton_get_property;
7866   gobject_class->set_property = org_freedesktop_udisks_skeleton_set_property;
7867   gobject_class->notify       = org_freedesktop_udisks_skeleton_notify;
7868
7869
7870   org_freedesktop_udisks_override_properties (gobject_class, 1);
7871
7872   skeleton_class = G_DBUS_INTERFACE_SKELETON_CLASS (klass);
7873   skeleton_class->get_info = org_freedesktop_udisks_skeleton_dbus_interface_get_info;
7874   skeleton_class->get_properties = org_freedesktop_udisks_skeleton_dbus_interface_get_properties;
7875   skeleton_class->flush = org_freedesktop_udisks_skeleton_dbus_interface_flush;
7876   skeleton_class->get_vtable = org_freedesktop_udisks_skeleton_dbus_interface_get_vtable;
7877
7878 #if GLIB_VERSION_MAX_ALLOWED < GLIB_VERSION_2_38
7879   g_type_class_add_private (klass, sizeof (OrgFreedesktopUDisksSkeletonPrivate));
7880 #endif
7881 }
7882
7883 static void
7884 org_freedesktop_udisks_skeleton_iface_init (OrgFreedesktopUDisksIface *iface)
7885 {
7886   iface->device_added = _org_freedesktop_udisks_on_signal_device_added;
7887   iface->device_removed = _org_freedesktop_udisks_on_signal_device_removed;
7888   iface->device_changed = _org_freedesktop_udisks_on_signal_device_changed;
7889   iface->device_job_changed = _org_freedesktop_udisks_on_signal_device_job_changed;
7890   iface->adapter_added = _org_freedesktop_udisks_on_signal_adapter_added;
7891   iface->adapter_removed = _org_freedesktop_udisks_on_signal_adapter_removed;
7892   iface->adapter_changed = _org_freedesktop_udisks_on_signal_adapter_changed;
7893   iface->expander_added = _org_freedesktop_udisks_on_signal_expander_added;
7894   iface->expander_removed = _org_freedesktop_udisks_on_signal_expander_removed;
7895   iface->expander_changed = _org_freedesktop_udisks_on_signal_expander_changed;
7896   iface->port_added = _org_freedesktop_udisks_on_signal_port_added;
7897   iface->port_removed = _org_freedesktop_udisks_on_signal_port_removed;
7898   iface->port_changed = _org_freedesktop_udisks_on_signal_port_changed;
7899   iface->get_daemon_version = org_freedesktop_udisks_skeleton_get_daemon_version;
7900   iface->get_daemon_is_inhibited = org_freedesktop_udisks_skeleton_get_daemon_is_inhibited;
7901   iface->get_supports_luks_devices = org_freedesktop_udisks_skeleton_get_supports_luks_devices;
7902   iface->get_known_filesystems = org_freedesktop_udisks_skeleton_get_known_filesystems;
7903 }
7904
7905 /**
7906  * org_freedesktop_udisks_skeleton_new:
7907  *
7908  * Creates a skeleton object for the D-Bus interface <link linkend="gdbus-interface-org-freedesktop-UDisks.top_of_page">org.freedesktop.UDisks</link>.
7909  *
7910  * Returns: (transfer full) (type OrgFreedesktopUDisksSkeleton): The skeleton object.
7911  */
7912 OrgFreedesktopUDisks *
7913 org_freedesktop_udisks_skeleton_new (void)
7914 {
7915   return ORG_FREEDESKTOP_UDISKS (g_object_new (TYPE_ORG_FREEDESKTOP_UDISKS_SKELETON, NULL));
7916 }
7917