/*
 * This file was generated by qdbusxml2cpp version 0.8
 * Command line was: qdbusxml2cpp -i /build/udisks2-qt5/src/udisks2-qt5-5.0.6/udisks2_dbus_common.h -N -p udisks2_interface.h: org.freedesktop.UDisks2.xml
 *
 * qdbusxml2cpp is Copyright (C) 2023 The Qt Company Ltd.
 *
 * This is an auto-generated file.
 * Do not edit! All changes made to it will be lost.
 */

#ifndef UDISKS2_INTERFACE_H
#define UDISKS2_INTERFACE_H

#include <QtCore/QObject>
#include <QtCore/QByteArray>
#include <QtCore/QList>
#include <QtCore/QMap>
#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtCore/QVariant>
#include <QtDBus/QtDBus>
#include "/build/udisks2-qt5/src/udisks2-qt5-5.0.6/udisks2_dbus_common.h"

/*
 * Proxy class for interface org.freedesktop.UDisks2.Block
 */
class OrgFreedesktopUDisks2BlockInterface: public QDBusAbstractInterface
{
    Q_OBJECT
public:
    static inline const char *staticInterfaceName()
    { return "org.freedesktop.UDisks2.Block"; }

public:
    OrgFreedesktopUDisks2BlockInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = nullptr);

    ~OrgFreedesktopUDisks2BlockInterface();

    Q_PROPERTY(QList<QPair<QString, QVariantMap>> Configuration READ configuration)
    inline QList<QPair<QString, QVariantMap>> configuration() const
    { return qvariant_cast< QList<QPair<QString, QVariantMap>> >(property("Configuration")); }

    Q_PROPERTY(QDBusObjectPath CryptoBackingDevice READ cryptoBackingDevice)
    inline QDBusObjectPath cryptoBackingDevice() const
    { return qvariant_cast< QDBusObjectPath >(property("CryptoBackingDevice")); }

    Q_PROPERTY(QByteArray Device READ device)
    inline QByteArray device() const
    { return qvariant_cast< QByteArray >(property("Device")); }

    Q_PROPERTY(qulonglong DeviceNumber READ deviceNumber)
    inline qulonglong deviceNumber() const
    { return qvariant_cast< qulonglong >(property("DeviceNumber")); }

    Q_PROPERTY(QDBusObjectPath Drive READ drive)
    inline QDBusObjectPath drive() const
    { return qvariant_cast< QDBusObjectPath >(property("Drive")); }

    Q_PROPERTY(bool HintAuto READ hintAuto)
    inline bool hintAuto() const
    { return qvariant_cast< bool >(property("HintAuto")); }

    Q_PROPERTY(QString HintIconName READ hintIconName)
    inline QString hintIconName() const
    { return qvariant_cast< QString >(property("HintIconName")); }

    Q_PROPERTY(bool HintIgnore READ hintIgnore)
    inline bool hintIgnore() const
    { return qvariant_cast< bool >(property("HintIgnore")); }

    Q_PROPERTY(QString HintName READ hintName)
    inline QString hintName() const
    { return qvariant_cast< QString >(property("HintName")); }

    Q_PROPERTY(bool HintPartitionable READ hintPartitionable)
    inline bool hintPartitionable() const
    { return qvariant_cast< bool >(property("HintPartitionable")); }

    Q_PROPERTY(QString HintSymbolicIconName READ hintSymbolicIconName)
    inline QString hintSymbolicIconName() const
    { return qvariant_cast< QString >(property("HintSymbolicIconName")); }

    Q_PROPERTY(bool HintSystem READ hintSystem)
    inline bool hintSystem() const
    { return qvariant_cast< bool >(property("HintSystem")); }

    Q_PROPERTY(QString Id READ id)
    inline QString id() const
    { return qvariant_cast< QString >(property("Id")); }

    Q_PROPERTY(QString IdLabel READ idLabel)
    inline QString idLabel() const
    { return qvariant_cast< QString >(property("IdLabel")); }

    Q_PROPERTY(QString IdType READ idType)
    inline QString idType() const
    { return qvariant_cast< QString >(property("IdType")); }

    Q_PROPERTY(QString IdUUID READ idUUID)
    inline QString idUUID() const
    { return qvariant_cast< QString >(property("IdUUID")); }

    Q_PROPERTY(QString IdUsage READ idUsage)
    inline QString idUsage() const
    { return qvariant_cast< QString >(property("IdUsage")); }

    Q_PROPERTY(QString IdVersion READ idVersion)
    inline QString idVersion() const
    { return qvariant_cast< QString >(property("IdVersion")); }

    Q_PROPERTY(QDBusObjectPath MDRaid READ mDRaid)
    inline QDBusObjectPath mDRaid() const
    { return qvariant_cast< QDBusObjectPath >(property("MDRaid")); }

    Q_PROPERTY(QDBusObjectPath MDRaidMember READ mDRaidMember)
    inline QDBusObjectPath mDRaidMember() const
    { return qvariant_cast< QDBusObjectPath >(property("MDRaidMember")); }

    Q_PROPERTY(QByteArray PreferredDevice READ preferredDevice)
    inline QByteArray preferredDevice() const
    { return qvariant_cast< QByteArray >(property("PreferredDevice")); }

    Q_PROPERTY(bool ReadOnly READ readOnly)
    inline bool readOnly() const
    { return qvariant_cast< bool >(property("ReadOnly")); }

    Q_PROPERTY(qulonglong Size READ size)
    inline qulonglong size() const
    { return qvariant_cast< qulonglong >(property("Size")); }

    Q_PROPERTY(QByteArrayList Symlinks READ symlinks)
    inline QByteArrayList symlinks() const
    { return qvariant_cast< QByteArrayList >(property("Symlinks")); }

    Q_PROPERTY(QStringList UserspaceMountOptions READ userspaceMountOptions)
    inline QStringList userspaceMountOptions() const
    { return qvariant_cast< QStringList >(property("UserspaceMountOptions")); }

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<> AddConfigurationItem(const QPair<QString, QVariantMap> &item, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(item) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("AddConfigurationItem"), argumentList);
    }

    inline QDBusPendingReply<> Format(const QString &type, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(type) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Format"), argumentList);
    }

    inline QDBusPendingReply<QList<QPair<QString, QVariantMap>> > GetSecretConfiguration(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("GetSecretConfiguration"), argumentList);
    }

    inline QDBusPendingReply<QDBusUnixFileDescriptor> OpenDevice(const QString &mode, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(mode) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("OpenDevice"), argumentList);
    }

    inline QDBusPendingReply<QDBusUnixFileDescriptor> OpenForBackup(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("OpenForBackup"), argumentList);
    }

    inline QDBusPendingReply<QDBusUnixFileDescriptor> OpenForBenchmark(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("OpenForBenchmark"), argumentList);
    }

    inline QDBusPendingReply<QDBusUnixFileDescriptor> OpenForRestore(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("OpenForRestore"), argumentList);
    }

    inline QDBusPendingReply<> RemoveConfigurationItem(const QPair<QString, QVariantMap> &item, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(item) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("RemoveConfigurationItem"), argumentList);
    }

    inline QDBusPendingReply<> Rescan(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Rescan"), argumentList);
    }

    inline QDBusPendingReply<> UpdateConfigurationItem(const QPair<QString, QVariantMap> &old_item, const QPair<QString, QVariantMap> &new_item, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(old_item) << QVariant::fromValue(new_item) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("UpdateConfigurationItem"), argumentList);
    }

Q_SIGNALS: // SIGNALS
};

/*
 * Proxy class for interface org.freedesktop.UDisks2.Drive
 */
class OrgFreedesktopUDisks2DriveInterface: public QDBusAbstractInterface
{
    Q_OBJECT
public:
    static inline const char *staticInterfaceName()
    { return "org.freedesktop.UDisks2.Drive"; }

public:
    OrgFreedesktopUDisks2DriveInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = nullptr);

    ~OrgFreedesktopUDisks2DriveInterface();

    Q_PROPERTY(bool CanPowerOff READ canPowerOff)
    inline bool canPowerOff() const
    { return qvariant_cast< bool >(property("CanPowerOff")); }

    Q_PROPERTY(QVariantMap Configuration READ configuration)
    inline QVariantMap configuration() const
    { return qvariant_cast< QVariantMap >(property("Configuration")); }

    Q_PROPERTY(QString ConnectionBus READ connectionBus)
    inline QString connectionBus() const
    { return qvariant_cast< QString >(property("ConnectionBus")); }

    Q_PROPERTY(bool Ejectable READ ejectable)
    inline bool ejectable() const
    { return qvariant_cast< bool >(property("Ejectable")); }

    Q_PROPERTY(QString Id READ id)
    inline QString id() const
    { return qvariant_cast< QString >(property("Id")); }

    Q_PROPERTY(QString Media READ media)
    inline QString media() const
    { return qvariant_cast< QString >(property("Media")); }

    Q_PROPERTY(bool MediaAvailable READ mediaAvailable)
    inline bool mediaAvailable() const
    { return qvariant_cast< bool >(property("MediaAvailable")); }

    Q_PROPERTY(bool MediaChangeDetected READ mediaChangeDetected)
    inline bool mediaChangeDetected() const
    { return qvariant_cast< bool >(property("MediaChangeDetected")); }

    Q_PROPERTY(QStringList MediaCompatibility READ mediaCompatibility)
    inline QStringList mediaCompatibility() const
    { return qvariant_cast< QStringList >(property("MediaCompatibility")); }

    Q_PROPERTY(bool MediaRemovable READ mediaRemovable)
    inline bool mediaRemovable() const
    { return qvariant_cast< bool >(property("MediaRemovable")); }

    Q_PROPERTY(QString Model READ model)
    inline QString model() const
    { return qvariant_cast< QString >(property("Model")); }

    Q_PROPERTY(bool Optical READ optical)
    inline bool optical() const
    { return qvariant_cast< bool >(property("Optical")); }

    Q_PROPERTY(bool OpticalBlank READ opticalBlank)
    inline bool opticalBlank() const
    { return qvariant_cast< bool >(property("OpticalBlank")); }

    Q_PROPERTY(uint OpticalNumAudioTracks READ opticalNumAudioTracks)
    inline uint opticalNumAudioTracks() const
    { return qvariant_cast< uint >(property("OpticalNumAudioTracks")); }

    Q_PROPERTY(uint OpticalNumDataTracks READ opticalNumDataTracks)
    inline uint opticalNumDataTracks() const
    { return qvariant_cast< uint >(property("OpticalNumDataTracks")); }

    Q_PROPERTY(uint OpticalNumSessions READ opticalNumSessions)
    inline uint opticalNumSessions() const
    { return qvariant_cast< uint >(property("OpticalNumSessions")); }

    Q_PROPERTY(uint OpticalNumTracks READ opticalNumTracks)
    inline uint opticalNumTracks() const
    { return qvariant_cast< uint >(property("OpticalNumTracks")); }

    Q_PROPERTY(bool Removable READ removable)
    inline bool removable() const
    { return qvariant_cast< bool >(property("Removable")); }

    Q_PROPERTY(QString Revision READ revision)
    inline QString revision() const
    { return qvariant_cast< QString >(property("Revision")); }

    Q_PROPERTY(int RotationRate READ rotationRate)
    inline int rotationRate() const
    { return qvariant_cast< int >(property("RotationRate")); }

    Q_PROPERTY(QString Seat READ seat)
    inline QString seat() const
    { return qvariant_cast< QString >(property("Seat")); }

    Q_PROPERTY(QString Serial READ serial)
    inline QString serial() const
    { return qvariant_cast< QString >(property("Serial")); }

    Q_PROPERTY(QString SiblingId READ siblingId)
    inline QString siblingId() const
    { return qvariant_cast< QString >(property("SiblingId")); }

    Q_PROPERTY(qulonglong Size READ size)
    inline qulonglong size() const
    { return qvariant_cast< qulonglong >(property("Size")); }

    Q_PROPERTY(QString SortKey READ sortKey)
    inline QString sortKey() const
    { return qvariant_cast< QString >(property("SortKey")); }

    Q_PROPERTY(qulonglong TimeDetected READ timeDetected)
    inline qulonglong timeDetected() const
    { return qvariant_cast< qulonglong >(property("TimeDetected")); }

    Q_PROPERTY(qulonglong TimeMediaDetected READ timeMediaDetected)
    inline qulonglong timeMediaDetected() const
    { return qvariant_cast< qulonglong >(property("TimeMediaDetected")); }

    Q_PROPERTY(QString Vendor READ vendor)
    inline QString vendor() const
    { return qvariant_cast< QString >(property("Vendor")); }

    Q_PROPERTY(QString WWN READ wWN)
    inline QString wWN() const
    { return qvariant_cast< QString >(property("WWN")); }

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<> Eject(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Eject"), argumentList);
    }

    inline QDBusPendingReply<> PowerOff(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("PowerOff"), argumentList);
    }

    inline QDBusPendingReply<> SetConfiguration(const QVariantMap &value, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(value) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SetConfiguration"), argumentList);
    }

Q_SIGNALS: // SIGNALS
};

/*
 * Proxy class for interface org.freedesktop.UDisks2.Drive.Ata
 */
class OrgFreedesktopUDisks2DriveAtaInterface: public QDBusAbstractInterface
{
    Q_OBJECT
public:
    static inline const char *staticInterfaceName()
    { return "org.freedesktop.UDisks2.Drive.Ata"; }

public:
    OrgFreedesktopUDisks2DriveAtaInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = nullptr);

    ~OrgFreedesktopUDisks2DriveAtaInterface();

    Q_PROPERTY(bool AamEnabled READ aamEnabled)
    inline bool aamEnabled() const
    { return qvariant_cast< bool >(property("AamEnabled")); }

    Q_PROPERTY(bool AamSupported READ aamSupported)
    inline bool aamSupported() const
    { return qvariant_cast< bool >(property("AamSupported")); }

    Q_PROPERTY(int AamVendorRecommendedValue READ aamVendorRecommendedValue)
    inline int aamVendorRecommendedValue() const
    { return qvariant_cast< int >(property("AamVendorRecommendedValue")); }

    Q_PROPERTY(bool ApmEnabled READ apmEnabled)
    inline bool apmEnabled() const
    { return qvariant_cast< bool >(property("ApmEnabled")); }

    Q_PROPERTY(bool ApmSupported READ apmSupported)
    inline bool apmSupported() const
    { return qvariant_cast< bool >(property("ApmSupported")); }

    Q_PROPERTY(bool PmEnabled READ pmEnabled)
    inline bool pmEnabled() const
    { return qvariant_cast< bool >(property("PmEnabled")); }

    Q_PROPERTY(bool PmSupported READ pmSupported)
    inline bool pmSupported() const
    { return qvariant_cast< bool >(property("PmSupported")); }

    Q_PROPERTY(bool ReadLookaheadEnabled READ readLookaheadEnabled)
    inline bool readLookaheadEnabled() const
    { return qvariant_cast< bool >(property("ReadLookaheadEnabled")); }

    Q_PROPERTY(bool ReadLookaheadSupported READ readLookaheadSupported)
    inline bool readLookaheadSupported() const
    { return qvariant_cast< bool >(property("ReadLookaheadSupported")); }

    Q_PROPERTY(int SecurityEnhancedEraseUnitMinutes READ securityEnhancedEraseUnitMinutes)
    inline int securityEnhancedEraseUnitMinutes() const
    { return qvariant_cast< int >(property("SecurityEnhancedEraseUnitMinutes")); }

    Q_PROPERTY(int SecurityEraseUnitMinutes READ securityEraseUnitMinutes)
    inline int securityEraseUnitMinutes() const
    { return qvariant_cast< int >(property("SecurityEraseUnitMinutes")); }

    Q_PROPERTY(bool SecurityFrozen READ securityFrozen)
    inline bool securityFrozen() const
    { return qvariant_cast< bool >(property("SecurityFrozen")); }

    Q_PROPERTY(bool SmartEnabled READ smartEnabled)
    inline bool smartEnabled() const
    { return qvariant_cast< bool >(property("SmartEnabled")); }

    Q_PROPERTY(bool SmartFailing READ smartFailing)
    inline bool smartFailing() const
    { return qvariant_cast< bool >(property("SmartFailing")); }

    Q_PROPERTY(int SmartNumAttributesFailedInThePast READ smartNumAttributesFailedInThePast)
    inline int smartNumAttributesFailedInThePast() const
    { return qvariant_cast< int >(property("SmartNumAttributesFailedInThePast")); }

    Q_PROPERTY(int SmartNumAttributesFailing READ smartNumAttributesFailing)
    inline int smartNumAttributesFailing() const
    { return qvariant_cast< int >(property("SmartNumAttributesFailing")); }

    Q_PROPERTY(qlonglong SmartNumBadSectors READ smartNumBadSectors)
    inline qlonglong smartNumBadSectors() const
    { return qvariant_cast< qlonglong >(property("SmartNumBadSectors")); }

    Q_PROPERTY(qulonglong SmartPowerOnSeconds READ smartPowerOnSeconds)
    inline qulonglong smartPowerOnSeconds() const
    { return qvariant_cast< qulonglong >(property("SmartPowerOnSeconds")); }

    Q_PROPERTY(int SmartSelftestPercentRemaining READ smartSelftestPercentRemaining)
    inline int smartSelftestPercentRemaining() const
    { return qvariant_cast< int >(property("SmartSelftestPercentRemaining")); }

    Q_PROPERTY(QString SmartSelftestStatus READ smartSelftestStatus)
    inline QString smartSelftestStatus() const
    { return qvariant_cast< QString >(property("SmartSelftestStatus")); }

    Q_PROPERTY(bool SmartSupported READ smartSupported)
    inline bool smartSupported() const
    { return qvariant_cast< bool >(property("SmartSupported")); }

    Q_PROPERTY(double SmartTemperature READ smartTemperature)
    inline double smartTemperature() const
    { return qvariant_cast< double >(property("SmartTemperature")); }

    Q_PROPERTY(qulonglong SmartUpdated READ smartUpdated)
    inline qulonglong smartUpdated() const
    { return qvariant_cast< qulonglong >(property("SmartUpdated")); }

    Q_PROPERTY(bool WriteCacheEnabled READ writeCacheEnabled)
    inline bool writeCacheEnabled() const
    { return qvariant_cast< bool >(property("WriteCacheEnabled")); }

    Q_PROPERTY(bool WriteCacheSupported READ writeCacheSupported)
    inline bool writeCacheSupported() const
    { return qvariant_cast< bool >(property("WriteCacheSupported")); }

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<uchar> PmGetState(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("PmGetState"), argumentList);
    }

    inline QDBusPendingReply<> PmStandby(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("PmStandby"), argumentList);
    }

    inline QDBusPendingReply<> PmWakeup(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("PmWakeup"), argumentList);
    }

    inline QDBusPendingReply<> SecurityEraseUnit(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SecurityEraseUnit"), argumentList);
    }

    inline QDBusPendingReply<QList<UDisks2::SmartAttribute> > SmartGetAttributes(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SmartGetAttributes"), argumentList);
    }

    inline QDBusPendingReply<> SmartSelftestAbort(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SmartSelftestAbort"), argumentList);
    }

    inline QDBusPendingReply<> SmartSelftestStart(const QString &type, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(type) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SmartSelftestStart"), argumentList);
    }

    inline QDBusPendingReply<> SmartSetEnabled(bool value, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(value) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SmartSetEnabled"), argumentList);
    }

    inline QDBusPendingReply<> SmartUpdate(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SmartUpdate"), argumentList);
    }

Q_SIGNALS: // SIGNALS
};

/*
 * Proxy class for interface org.freedesktop.UDisks2.Encrypted
 */
class OrgFreedesktopUDisks2EncryptedInterface: public QDBusAbstractInterface
{
    Q_OBJECT
public:
    static inline const char *staticInterfaceName()
    { return "org.freedesktop.UDisks2.Encrypted"; }

public:
    OrgFreedesktopUDisks2EncryptedInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = nullptr);

    ~OrgFreedesktopUDisks2EncryptedInterface();

    Q_PROPERTY(QList<QPair<QString, QVariantMap>> ChildConfiguration READ childConfiguration)
    inline QList<QPair<QString, QVariantMap>> childConfiguration() const
    { return qvariant_cast< QList<QPair<QString, QVariantMap>> >(property("ChildConfiguration")); }

    Q_PROPERTY(QDBusObjectPath CleartextDevice READ cleartextDevice)
    inline QDBusObjectPath cleartextDevice() const
    { return qvariant_cast< QDBusObjectPath >(property("CleartextDevice")); }

    Q_PROPERTY(QString HintEncryptionType READ hintEncryptionType)
    inline QString hintEncryptionType() const
    { return qvariant_cast< QString >(property("HintEncryptionType")); }

    Q_PROPERTY(qulonglong MetadataSize READ metadataSize)
    inline qulonglong metadataSize() const
    { return qvariant_cast< qulonglong >(property("MetadataSize")); }

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<> ChangePassphrase(const QString &passphrase, const QString &new_passphrase, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(passphrase) << QVariant::fromValue(new_passphrase) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("ChangePassphrase"), argumentList);
    }

    inline QDBusPendingReply<> Lock(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Lock"), argumentList);
    }

    inline QDBusPendingReply<> Resize(qulonglong size, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(size) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Resize"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> Unlock(const QString &passphrase, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(passphrase) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Unlock"), argumentList);
    }

Q_SIGNALS: // SIGNALS
};

/*
 * Proxy class for interface org.freedesktop.UDisks2.Filesystem
 */
class OrgFreedesktopUDisks2FilesystemInterface: public QDBusAbstractInterface
{
    Q_OBJECT
public:
    static inline const char *staticInterfaceName()
    { return "org.freedesktop.UDisks2.Filesystem"; }

public:
    OrgFreedesktopUDisks2FilesystemInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = nullptr);

    ~OrgFreedesktopUDisks2FilesystemInterface();

    Q_PROPERTY(QByteArrayList MountPoints READ mountPoints)
    inline QByteArrayList mountPoints() const
    { return qvariant_cast< QByteArrayList >(property("MountPoints")); }

    Q_PROPERTY(qulonglong Size READ size)
    inline qulonglong size() const
    { return qvariant_cast< qulonglong >(property("Size")); }

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<bool> Check(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Check"), argumentList);
    }

    inline QDBusPendingReply<QString> Mount(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Mount"), argumentList);
    }

    inline QDBusPendingReply<bool> Repair(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Repair"), argumentList);
    }

    inline QDBusPendingReply<> Resize(qulonglong size, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(size) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Resize"), argumentList);
    }

    inline QDBusPendingReply<> SetLabel(const QString &label, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(label) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SetLabel"), argumentList);
    }

    inline QDBusPendingReply<> TakeOwnership(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("TakeOwnership"), argumentList);
    }

    inline QDBusPendingReply<> Unmount(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Unmount"), argumentList);
    }

Q_SIGNALS: // SIGNALS
};

/*
 * Proxy class for interface org.freedesktop.UDisks2.Job
 */
class OrgFreedesktopUDisks2JobInterface: public QDBusAbstractInterface
{
    Q_OBJECT
public:
    static inline const char *staticInterfaceName()
    { return "org.freedesktop.UDisks2.Job"; }

public:
    OrgFreedesktopUDisks2JobInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = nullptr);

    ~OrgFreedesktopUDisks2JobInterface();

    Q_PROPERTY(qulonglong Bytes READ bytes)
    inline qulonglong bytes() const
    { return qvariant_cast< qulonglong >(property("Bytes")); }

    Q_PROPERTY(bool Cancelable READ cancelable)
    inline bool cancelable() const
    { return qvariant_cast< bool >(property("Cancelable")); }

    Q_PROPERTY(qulonglong ExpectedEndTime READ expectedEndTime)
    inline qulonglong expectedEndTime() const
    { return qvariant_cast< qulonglong >(property("ExpectedEndTime")); }

    Q_PROPERTY(QList<QDBusObjectPath> Objects READ objects)
    inline QList<QDBusObjectPath> objects() const
    { return qvariant_cast< QList<QDBusObjectPath> >(property("Objects")); }

    Q_PROPERTY(QString Operation READ operation)
    inline QString operation() const
    { return qvariant_cast< QString >(property("Operation")); }

    Q_PROPERTY(double Progress READ progress)
    inline double progress() const
    { return qvariant_cast< double >(property("Progress")); }

    Q_PROPERTY(bool ProgressValid READ progressValid)
    inline bool progressValid() const
    { return qvariant_cast< bool >(property("ProgressValid")); }

    Q_PROPERTY(qulonglong Rate READ rate)
    inline qulonglong rate() const
    { return qvariant_cast< qulonglong >(property("Rate")); }

    Q_PROPERTY(qulonglong StartTime READ startTime)
    inline qulonglong startTime() const
    { return qvariant_cast< qulonglong >(property("StartTime")); }

    Q_PROPERTY(uint StartedByUID READ startedByUID)
    inline uint startedByUID() const
    { return qvariant_cast< uint >(property("StartedByUID")); }

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<> Cancel(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Cancel"), argumentList);
    }

Q_SIGNALS: // SIGNALS
    void Completed(bool success, const QString &message);
};

/*
 * Proxy class for interface org.freedesktop.UDisks2.Loop
 */
class OrgFreedesktopUDisks2LoopInterface: public QDBusAbstractInterface
{
    Q_OBJECT
public:
    static inline const char *staticInterfaceName()
    { return "org.freedesktop.UDisks2.Loop"; }

public:
    OrgFreedesktopUDisks2LoopInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = nullptr);

    ~OrgFreedesktopUDisks2LoopInterface();

    Q_PROPERTY(bool Autoclear READ autoclear)
    inline bool autoclear() const
    { return qvariant_cast< bool >(property("Autoclear")); }

    Q_PROPERTY(QByteArray BackingFile READ backingFile)
    inline QByteArray backingFile() const
    { return qvariant_cast< QByteArray >(property("BackingFile")); }

    Q_PROPERTY(uint SetupByUID READ setupByUID)
    inline uint setupByUID() const
    { return qvariant_cast< uint >(property("SetupByUID")); }

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<> Delete(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Delete"), argumentList);
    }

    inline QDBusPendingReply<> SetAutoclear(bool value, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(value) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SetAutoclear"), argumentList);
    }

Q_SIGNALS: // SIGNALS
};

/*
 * Proxy class for interface org.freedesktop.UDisks2.MDRaid
 */
class OrgFreedesktopUDisks2MDRaidInterface: public QDBusAbstractInterface
{
    Q_OBJECT
public:
    static inline const char *staticInterfaceName()
    { return "org.freedesktop.UDisks2.MDRaid"; }

public:
    OrgFreedesktopUDisks2MDRaidInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = nullptr);

    ~OrgFreedesktopUDisks2MDRaidInterface();

    Q_PROPERTY(QList<UDisks2::ActiveDeviceInfo> ActiveDevices READ activeDevices)
    inline QList<UDisks2::ActiveDeviceInfo> activeDevices() const
    { return qvariant_cast< QList<UDisks2::ActiveDeviceInfo> >(property("ActiveDevices")); }

    Q_PROPERTY(QByteArray BitmapLocation READ bitmapLocation)
    inline QByteArray bitmapLocation() const
    { return qvariant_cast< QByteArray >(property("BitmapLocation")); }

    Q_PROPERTY(QList<QPair<QString, QVariantMap>> ChildConfiguration READ childConfiguration)
    inline QList<QPair<QString, QVariantMap>> childConfiguration() const
    { return qvariant_cast< QList<QPair<QString, QVariantMap>> >(property("ChildConfiguration")); }

    Q_PROPERTY(qulonglong ChunkSize READ chunkSize)
    inline qulonglong chunkSize() const
    { return qvariant_cast< qulonglong >(property("ChunkSize")); }

    Q_PROPERTY(uint Degraded READ degraded)
    inline uint degraded() const
    { return qvariant_cast< uint >(property("Degraded")); }

    Q_PROPERTY(QString Level READ level)
    inline QString level() const
    { return qvariant_cast< QString >(property("Level")); }

    Q_PROPERTY(QString Name READ name)
    inline QString name() const
    { return qvariant_cast< QString >(property("Name")); }

    Q_PROPERTY(uint NumDevices READ numDevices)
    inline uint numDevices() const
    { return qvariant_cast< uint >(property("NumDevices")); }

    Q_PROPERTY(bool Running READ running)
    inline bool running() const
    { return qvariant_cast< bool >(property("Running")); }

    Q_PROPERTY(qulonglong Size READ size)
    inline qulonglong size() const
    { return qvariant_cast< qulonglong >(property("Size")); }

    Q_PROPERTY(QString SyncAction READ syncAction)
    inline QString syncAction() const
    { return qvariant_cast< QString >(property("SyncAction")); }

    Q_PROPERTY(double SyncCompleted READ syncCompleted)
    inline double syncCompleted() const
    { return qvariant_cast< double >(property("SyncCompleted")); }

    Q_PROPERTY(qulonglong SyncRate READ syncRate)
    inline qulonglong syncRate() const
    { return qvariant_cast< qulonglong >(property("SyncRate")); }

    Q_PROPERTY(qulonglong SyncRemainingTime READ syncRemainingTime)
    inline qulonglong syncRemainingTime() const
    { return qvariant_cast< qulonglong >(property("SyncRemainingTime")); }

    Q_PROPERTY(QString UUID READ uUID)
    inline QString uUID() const
    { return qvariant_cast< QString >(property("UUID")); }

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<> AddDevice(const QDBusObjectPath &device, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(device) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("AddDevice"), argumentList);
    }

    inline QDBusPendingReply<> Delete(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Delete"), argumentList);
    }

    inline QDBusPendingReply<> RemoveDevice(const QDBusObjectPath &device, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(device) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("RemoveDevice"), argumentList);
    }

    inline QDBusPendingReply<> RequestSyncAction(const QString &sync_action, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(sync_action) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("RequestSyncAction"), argumentList);
    }

    inline QDBusPendingReply<> SetBitmapLocation(const QByteArray &value, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(value) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SetBitmapLocation"), argumentList);
    }

    inline QDBusPendingReply<> Start(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Start"), argumentList);
    }

    inline QDBusPendingReply<> Stop(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Stop"), argumentList);
    }

Q_SIGNALS: // SIGNALS
};

/*
 * Proxy class for interface org.freedesktop.UDisks2.Manager
 */
class OrgFreedesktopUDisks2ManagerInterface: public QDBusAbstractInterface
{
    Q_OBJECT
public:
    static inline const char *staticInterfaceName()
    { return "org.freedesktop.UDisks2.Manager"; }

public:
    OrgFreedesktopUDisks2ManagerInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = nullptr);

    ~OrgFreedesktopUDisks2ManagerInterface();

    Q_PROPERTY(QString DefaultEncryptionType READ defaultEncryptionType)
    inline QString defaultEncryptionType() const
    { return qvariant_cast< QString >(property("DefaultEncryptionType")); }

    Q_PROPERTY(QStringList SupportedEncryptionTypes READ supportedEncryptionTypes)
    inline QStringList supportedEncryptionTypes() const
    { return qvariant_cast< QStringList >(property("SupportedEncryptionTypes")); }

    Q_PROPERTY(QStringList SupportedFilesystems READ supportedFilesystems)
    inline QStringList supportedFilesystems() const
    { return qvariant_cast< QStringList >(property("SupportedFilesystems")); }

    Q_PROPERTY(QString Version READ version)
    inline QString version() const
    { return qvariant_cast< QString >(property("Version")); }

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<QPair<bool, QString> > CanCheck(const QString &type)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(type);
        return asyncCallWithArgumentList(QStringLiteral("CanCheck"), argumentList);
    }

    inline QDBusPendingReply<QPair<bool, QString> > CanFormat(const QString &type)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(type);
        return asyncCallWithArgumentList(QStringLiteral("CanFormat"), argumentList);
    }

    inline QDBusPendingReply<QPair<bool, QString> > CanRepair(const QString &type)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(type);
        return asyncCallWithArgumentList(QStringLiteral("CanRepair"), argumentList);
    }

    inline QDBusPendingReply<QPair<bool, QPair<quint64, QString>> > CanResize(const QString &type)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(type);
        return asyncCallWithArgumentList(QStringLiteral("CanResize"), argumentList);
    }

    inline QDBusPendingReply<> EnableModules(bool enable)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(enable);
        return asyncCallWithArgumentList(QStringLiteral("EnableModules"), argumentList);
    }

    inline QDBusPendingReply<QList<QDBusObjectPath> > GetBlockDevices(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("GetBlockDevices"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> LoopSetup(const QDBusUnixFileDescriptor &fd, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(fd) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("LoopSetup"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> MDRaidCreate(const QList<QDBusObjectPath> &blocks, const QString &level, const QString &name, qulonglong chunk, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(blocks) << QVariant::fromValue(level) << QVariant::fromValue(name) << QVariant::fromValue(chunk) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("MDRaidCreate"), argumentList);
    }

    inline QDBusPendingReply<QList<QDBusObjectPath> > ResolveDevice(const QVariantMap &devspec, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(devspec) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("ResolveDevice"), argumentList);
    }

Q_SIGNALS: // SIGNALS
};

/*
 * Proxy class for interface org.freedesktop.UDisks2.Partition
 */
class OrgFreedesktopUDisks2PartitionInterface: public QDBusAbstractInterface
{
    Q_OBJECT
public:
    static inline const char *staticInterfaceName()
    { return "org.freedesktop.UDisks2.Partition"; }

public:
    OrgFreedesktopUDisks2PartitionInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = nullptr);

    ~OrgFreedesktopUDisks2PartitionInterface();

    Q_PROPERTY(qulonglong Flags READ flags)
    inline qulonglong flags() const
    { return qvariant_cast< qulonglong >(property("Flags")); }

    Q_PROPERTY(bool IsContained READ isContained)
    inline bool isContained() const
    { return qvariant_cast< bool >(property("IsContained")); }

    Q_PROPERTY(bool IsContainer READ isContainer)
    inline bool isContainer() const
    { return qvariant_cast< bool >(property("IsContainer")); }

    Q_PROPERTY(QString Name READ name)
    inline QString name() const
    { return qvariant_cast< QString >(property("Name")); }

    Q_PROPERTY(uint Number READ number)
    inline uint number() const
    { return qvariant_cast< uint >(property("Number")); }

    Q_PROPERTY(qulonglong Offset READ offset)
    inline qulonglong offset() const
    { return qvariant_cast< qulonglong >(property("Offset")); }

    Q_PROPERTY(qulonglong Size READ size)
    inline qulonglong size() const
    { return qvariant_cast< qulonglong >(property("Size")); }

    Q_PROPERTY(QDBusObjectPath Table READ table)
    inline QDBusObjectPath table() const
    { return qvariant_cast< QDBusObjectPath >(property("Table")); }

    Q_PROPERTY(QString Type READ type)
    inline QString type() const
    { return qvariant_cast< QString >(property("Type")); }

    Q_PROPERTY(QString UUID READ uUID)
    inline QString uUID() const
    { return qvariant_cast< QString >(property("UUID")); }

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<> Delete(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Delete"), argumentList);
    }

    inline QDBusPendingReply<> Resize(qulonglong size, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(size) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Resize"), argumentList);
    }

    inline QDBusPendingReply<> SetFlags(qulonglong flags, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(flags) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SetFlags"), argumentList);
    }

    inline QDBusPendingReply<> SetName(const QString &name, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(name) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SetName"), argumentList);
    }

    inline QDBusPendingReply<> SetType(const QString &type, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(type) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SetType"), argumentList);
    }

Q_SIGNALS: // SIGNALS
};

/*
 * Proxy class for interface org.freedesktop.UDisks2.PartitionTable
 */
class OrgFreedesktopUDisks2PartitionTableInterface: public QDBusAbstractInterface
{
    Q_OBJECT
public:
    static inline const char *staticInterfaceName()
    { return "org.freedesktop.UDisks2.PartitionTable"; }

public:
    OrgFreedesktopUDisks2PartitionTableInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = nullptr);

    ~OrgFreedesktopUDisks2PartitionTableInterface();

    Q_PROPERTY(QList<QDBusObjectPath> Partitions READ partitions)
    inline QList<QDBusObjectPath> partitions() const
    { return qvariant_cast< QList<QDBusObjectPath> >(property("Partitions")); }

    Q_PROPERTY(QString Type READ type)
    inline QString type() const
    { return qvariant_cast< QString >(property("Type")); }

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<QDBusObjectPath> CreatePartition(qulonglong offset, qulonglong size, const QString &type, const QString &name, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(offset) << QVariant::fromValue(size) << QVariant::fromValue(type) << QVariant::fromValue(name) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("CreatePartition"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> CreatePartitionAndFormat(qulonglong offset, qulonglong size, const QString &type, const QString &name, const QVariantMap &options, const QString &format_type, const QVariantMap &format_options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(offset) << QVariant::fromValue(size) << QVariant::fromValue(type) << QVariant::fromValue(name) << QVariant::fromValue(options) << QVariant::fromValue(format_type) << QVariant::fromValue(format_options);
        return asyncCallWithArgumentList(QStringLiteral("CreatePartitionAndFormat"), argumentList);
    }

Q_SIGNALS: // SIGNALS
};

/*
 * Proxy class for interface org.freedesktop.UDisks2.Swapspace
 */
class OrgFreedesktopUDisks2SwapspaceInterface: public QDBusAbstractInterface
{
    Q_OBJECT
public:
    static inline const char *staticInterfaceName()
    { return "org.freedesktop.UDisks2.Swapspace"; }

public:
    OrgFreedesktopUDisks2SwapspaceInterface(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent = nullptr);

    ~OrgFreedesktopUDisks2SwapspaceInterface();

    Q_PROPERTY(bool Active READ active)
    inline bool active() const
    { return qvariant_cast< bool >(property("Active")); }

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<> SetLabel(const QString &label, const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(label) << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("SetLabel"), argumentList);
    }

    inline QDBusPendingReply<> Start(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Start"), argumentList);
    }

    inline QDBusPendingReply<> Stop(const QVariantMap &options)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(options);
        return asyncCallWithArgumentList(QStringLiteral("Stop"), argumentList);
    }

Q_SIGNALS: // SIGNALS
};

#endif
