/****************************************************************************
** Meta object code from reading C++ file 'udisks2_interface.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.15.19)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/

#include <memory>
#include "udisks2_interface.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#include <QtCore/QList>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'udisks2_interface.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.15.19. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

QT_BEGIN_MOC_NAMESPACE
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_OrgFreedesktopUDisks2BlockInterface_t {
    QByteArrayData data[49];
    char stringdata0[713];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_OrgFreedesktopUDisks2BlockInterface_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_OrgFreedesktopUDisks2BlockInterface_t qt_meta_stringdata_OrgFreedesktopUDisks2BlockInterface = {
    {
QT_MOC_LITERAL(0, 0, 35), // "OrgFreedesktopUDisks2BlockInt..."
QT_MOC_LITERAL(1, 36, 20), // "AddConfigurationItem"
QT_MOC_LITERAL(2, 57, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(3, 77, 0), // ""
QT_MOC_LITERAL(4, 78, 26), // "QPair<QString,QVariantMap>"
QT_MOC_LITERAL(5, 105, 4), // "item"
QT_MOC_LITERAL(6, 110, 7), // "options"
QT_MOC_LITERAL(7, 118, 6), // "Format"
QT_MOC_LITERAL(8, 125, 4), // "type"
QT_MOC_LITERAL(9, 130, 22), // "GetSecretConfiguration"
QT_MOC_LITERAL(10, 153, 54), // "QDBusPendingReply<QList<QPair..."
QT_MOC_LITERAL(11, 208, 10), // "OpenDevice"
QT_MOC_LITERAL(12, 219, 42), // "QDBusPendingReply<QDBusUnixFi..."
QT_MOC_LITERAL(13, 262, 4), // "mode"
QT_MOC_LITERAL(14, 267, 13), // "OpenForBackup"
QT_MOC_LITERAL(15, 281, 16), // "OpenForBenchmark"
QT_MOC_LITERAL(16, 298, 14), // "OpenForRestore"
QT_MOC_LITERAL(17, 313, 23), // "RemoveConfigurationItem"
QT_MOC_LITERAL(18, 337, 6), // "Rescan"
QT_MOC_LITERAL(19, 344, 23), // "UpdateConfigurationItem"
QT_MOC_LITERAL(20, 368, 8), // "old_item"
QT_MOC_LITERAL(21, 377, 8), // "new_item"
QT_MOC_LITERAL(22, 386, 13), // "Configuration"
QT_MOC_LITERAL(23, 400, 34), // "QList<QPair<QString,QVariantM..."
QT_MOC_LITERAL(24, 435, 19), // "CryptoBackingDevice"
QT_MOC_LITERAL(25, 455, 15), // "QDBusObjectPath"
QT_MOC_LITERAL(26, 471, 6), // "Device"
QT_MOC_LITERAL(27, 478, 12), // "DeviceNumber"
QT_MOC_LITERAL(28, 491, 5), // "Drive"
QT_MOC_LITERAL(29, 497, 8), // "HintAuto"
QT_MOC_LITERAL(30, 506, 12), // "HintIconName"
QT_MOC_LITERAL(31, 519, 10), // "HintIgnore"
QT_MOC_LITERAL(32, 530, 8), // "HintName"
QT_MOC_LITERAL(33, 539, 17), // "HintPartitionable"
QT_MOC_LITERAL(34, 557, 20), // "HintSymbolicIconName"
QT_MOC_LITERAL(35, 578, 10), // "HintSystem"
QT_MOC_LITERAL(36, 589, 2), // "Id"
QT_MOC_LITERAL(37, 592, 7), // "IdLabel"
QT_MOC_LITERAL(38, 600, 6), // "IdType"
QT_MOC_LITERAL(39, 607, 6), // "IdUUID"
QT_MOC_LITERAL(40, 614, 7), // "IdUsage"
QT_MOC_LITERAL(41, 622, 9), // "IdVersion"
QT_MOC_LITERAL(42, 632, 6), // "MDRaid"
QT_MOC_LITERAL(43, 639, 12), // "MDRaidMember"
QT_MOC_LITERAL(44, 652, 15), // "PreferredDevice"
QT_MOC_LITERAL(45, 668, 8), // "ReadOnly"
QT_MOC_LITERAL(46, 677, 4), // "Size"
QT_MOC_LITERAL(47, 682, 8), // "Symlinks"
QT_MOC_LITERAL(48, 691, 21) // "UserspaceMountOptions"

    },
    "OrgFreedesktopUDisks2BlockInterface\0"
    "AddConfigurationItem\0QDBusPendingReply<>\0"
    "\0QPair<QString,QVariantMap>\0item\0"
    "options\0Format\0type\0GetSecretConfiguration\0"
    "QDBusPendingReply<QList<QPair<QString,QVariantMap> > >\0"
    "OpenDevice\0QDBusPendingReply<QDBusUnixFileDescriptor>\0"
    "mode\0OpenForBackup\0OpenForBenchmark\0"
    "OpenForRestore\0RemoveConfigurationItem\0"
    "Rescan\0UpdateConfigurationItem\0old_item\0"
    "new_item\0Configuration\0"
    "QList<QPair<QString,QVariantMap> >\0"
    "CryptoBackingDevice\0QDBusObjectPath\0"
    "Device\0DeviceNumber\0Drive\0HintAuto\0"
    "HintIconName\0HintIgnore\0HintName\0"
    "HintPartitionable\0HintSymbolicIconName\0"
    "HintSystem\0Id\0IdLabel\0IdType\0IdUUID\0"
    "IdUsage\0IdVersion\0MDRaid\0MDRaidMember\0"
    "PreferredDevice\0ReadOnly\0Size\0Symlinks\0"
    "UserspaceMountOptions"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_OrgFreedesktopUDisks2BlockInterface[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
      10,   14, // methods
      25,  106, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    2,   64,    3, 0x0a /* Public */,
       7,    2,   69,    3, 0x0a /* Public */,
       9,    1,   74,    3, 0x0a /* Public */,
      11,    2,   77,    3, 0x0a /* Public */,
      14,    1,   82,    3, 0x0a /* Public */,
      15,    1,   85,    3, 0x0a /* Public */,
      16,    1,   88,    3, 0x0a /* Public */,
      17,    2,   91,    3, 0x0a /* Public */,
      18,    1,   96,    3, 0x0a /* Public */,
      19,    3,   99,    3, 0x0a /* Public */,

 // slots: parameters
    0x80000000 | 2, 0x80000000 | 4, QMetaType::QVariantMap,    5,    6,
    0x80000000 | 2, QMetaType::QString, QMetaType::QVariantMap,    8,    6,
    0x80000000 | 10, QMetaType::QVariantMap,    6,
    0x80000000 | 12, QMetaType::QString, QMetaType::QVariantMap,   13,    6,
    0x80000000 | 12, QMetaType::QVariantMap,    6,
    0x80000000 | 12, QMetaType::QVariantMap,    6,
    0x80000000 | 12, QMetaType::QVariantMap,    6,
    0x80000000 | 2, 0x80000000 | 4, QMetaType::QVariantMap,    5,    6,
    0x80000000 | 2, QMetaType::QVariantMap,    6,
    0x80000000 | 2, 0x80000000 | 4, 0x80000000 | 4, QMetaType::QVariantMap,   20,   21,    6,

 // properties: name, type, flags
      22, 0x80000000 | 23, 0x00095009,
      24, 0x80000000 | 25, 0x00095009,
      26, QMetaType::QByteArray, 0x00095001,
      27, QMetaType::ULongLong, 0x00095001,
      28, 0x80000000 | 25, 0x00095009,
      29, QMetaType::Bool, 0x00095001,
      30, QMetaType::QString, 0x00095001,
      31, QMetaType::Bool, 0x00095001,
      32, QMetaType::QString, 0x00095001,
      33, QMetaType::Bool, 0x00095001,
      34, QMetaType::QString, 0x00095001,
      35, QMetaType::Bool, 0x00095001,
      36, QMetaType::QString, 0x00095001,
      37, QMetaType::QString, 0x00095001,
      38, QMetaType::QString, 0x00095001,
      39, QMetaType::QString, 0x00095001,
      40, QMetaType::QString, 0x00095001,
      41, QMetaType::QString, 0x00095001,
      42, 0x80000000 | 25, 0x00095009,
      43, 0x80000000 | 25, 0x00095009,
      44, QMetaType::QByteArray, 0x00095001,
      45, QMetaType::Bool, 0x00095001,
      46, QMetaType::ULongLong, 0x00095001,
      47, QMetaType::QByteArrayList, 0x00095001,
      48, QMetaType::QStringList, 0x00095001,

       0        // eod
};

void OrgFreedesktopUDisks2BlockInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<OrgFreedesktopUDisks2BlockInterface *>(_o);
        (void)_t;
        switch (_id) {
        case 0: { QDBusPendingReply<> _r = _t->AddConfigurationItem((*reinterpret_cast< const QPair<QString,QVariantMap>(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 1: { QDBusPendingReply<> _r = _t->Format((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 2: { QDBusPendingReply<QList<QPair<QString,QVariantMap> > > _r = _t->GetSecretConfiguration((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QList<QPair<QString,QVariantMap> > >*>(_a[0]) = std::move(_r); }  break;
        case 3: { QDBusPendingReply<QDBusUnixFileDescriptor> _r = _t->OpenDevice((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusUnixFileDescriptor>*>(_a[0]) = std::move(_r); }  break;
        case 4: { QDBusPendingReply<QDBusUnixFileDescriptor> _r = _t->OpenForBackup((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusUnixFileDescriptor>*>(_a[0]) = std::move(_r); }  break;
        case 5: { QDBusPendingReply<QDBusUnixFileDescriptor> _r = _t->OpenForBenchmark((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusUnixFileDescriptor>*>(_a[0]) = std::move(_r); }  break;
        case 6: { QDBusPendingReply<QDBusUnixFileDescriptor> _r = _t->OpenForRestore((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusUnixFileDescriptor>*>(_a[0]) = std::move(_r); }  break;
        case 7: { QDBusPendingReply<> _r = _t->RemoveConfigurationItem((*reinterpret_cast< const QPair<QString,QVariantMap>(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 8: { QDBusPendingReply<> _r = _t->Rescan((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 9: { QDBusPendingReply<> _r = _t->UpdateConfigurationItem((*reinterpret_cast< const QPair<QString,QVariantMap>(*)>(_a[1])),(*reinterpret_cast< const QPair<QString,QVariantMap>(*)>(_a[2])),(*reinterpret_cast< const QVariantMap(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 19:
        case 18:
        case 4:
        case 1:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusObjectPath >(); break;
        }
    }

#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<OrgFreedesktopUDisks2BlockInterface *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QList<QPair<QString,QVariantMap> >*>(_v) = _t->configuration(); break;
        case 1: *reinterpret_cast< QDBusObjectPath*>(_v) = _t->cryptoBackingDevice(); break;
        case 2: *reinterpret_cast< QByteArray*>(_v) = _t->device(); break;
        case 3: *reinterpret_cast< qulonglong*>(_v) = _t->deviceNumber(); break;
        case 4: *reinterpret_cast< QDBusObjectPath*>(_v) = _t->drive(); break;
        case 5: *reinterpret_cast< bool*>(_v) = _t->hintAuto(); break;
        case 6: *reinterpret_cast< QString*>(_v) = _t->hintIconName(); break;
        case 7: *reinterpret_cast< bool*>(_v) = _t->hintIgnore(); break;
        case 8: *reinterpret_cast< QString*>(_v) = _t->hintName(); break;
        case 9: *reinterpret_cast< bool*>(_v) = _t->hintPartitionable(); break;
        case 10: *reinterpret_cast< QString*>(_v) = _t->hintSymbolicIconName(); break;
        case 11: *reinterpret_cast< bool*>(_v) = _t->hintSystem(); break;
        case 12: *reinterpret_cast< QString*>(_v) = _t->id(); break;
        case 13: *reinterpret_cast< QString*>(_v) = _t->idLabel(); break;
        case 14: *reinterpret_cast< QString*>(_v) = _t->idType(); break;
        case 15: *reinterpret_cast< QString*>(_v) = _t->idUUID(); break;
        case 16: *reinterpret_cast< QString*>(_v) = _t->idUsage(); break;
        case 17: *reinterpret_cast< QString*>(_v) = _t->idVersion(); break;
        case 18: *reinterpret_cast< QDBusObjectPath*>(_v) = _t->mDRaid(); break;
        case 19: *reinterpret_cast< QDBusObjectPath*>(_v) = _t->mDRaidMember(); break;
        case 20: *reinterpret_cast< QByteArray*>(_v) = _t->preferredDevice(); break;
        case 21: *reinterpret_cast< bool*>(_v) = _t->readOnly(); break;
        case 22: *reinterpret_cast< qulonglong*>(_v) = _t->size(); break;
        case 23: *reinterpret_cast< QByteArrayList*>(_v) = _t->symlinks(); break;
        case 24: *reinterpret_cast< QStringList*>(_v) = _t->userspaceMountOptions(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

QT_INIT_METAOBJECT const QMetaObject OrgFreedesktopUDisks2BlockInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
    qt_meta_stringdata_OrgFreedesktopUDisks2BlockInterface.data,
    qt_meta_data_OrgFreedesktopUDisks2BlockInterface,
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *OrgFreedesktopUDisks2BlockInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *OrgFreedesktopUDisks2BlockInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_OrgFreedesktopUDisks2BlockInterface.stringdata0))
        return static_cast<void*>(this);
    return QDBusAbstractInterface::qt_metacast(_clname);
}

int OrgFreedesktopUDisks2BlockInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 10)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 10;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 10)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 10;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 25;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
struct qt_meta_stringdata_OrgFreedesktopUDisks2DriveInterface_t {
    QByteArrayData data[37];
    char stringdata0[446];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_OrgFreedesktopUDisks2DriveInterface_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_OrgFreedesktopUDisks2DriveInterface_t qt_meta_stringdata_OrgFreedesktopUDisks2DriveInterface = {
    {
QT_MOC_LITERAL(0, 0, 35), // "OrgFreedesktopUDisks2DriveInt..."
QT_MOC_LITERAL(1, 36, 5), // "Eject"
QT_MOC_LITERAL(2, 42, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(3, 62, 0), // ""
QT_MOC_LITERAL(4, 63, 7), // "options"
QT_MOC_LITERAL(5, 71, 8), // "PowerOff"
QT_MOC_LITERAL(6, 80, 16), // "SetConfiguration"
QT_MOC_LITERAL(7, 97, 5), // "value"
QT_MOC_LITERAL(8, 103, 11), // "CanPowerOff"
QT_MOC_LITERAL(9, 115, 13), // "Configuration"
QT_MOC_LITERAL(10, 129, 13), // "ConnectionBus"
QT_MOC_LITERAL(11, 143, 9), // "Ejectable"
QT_MOC_LITERAL(12, 153, 2), // "Id"
QT_MOC_LITERAL(13, 156, 5), // "Media"
QT_MOC_LITERAL(14, 162, 14), // "MediaAvailable"
QT_MOC_LITERAL(15, 177, 19), // "MediaChangeDetected"
QT_MOC_LITERAL(16, 197, 18), // "MediaCompatibility"
QT_MOC_LITERAL(17, 216, 14), // "MediaRemovable"
QT_MOC_LITERAL(18, 231, 5), // "Model"
QT_MOC_LITERAL(19, 237, 7), // "Optical"
QT_MOC_LITERAL(20, 245, 12), // "OpticalBlank"
QT_MOC_LITERAL(21, 258, 21), // "OpticalNumAudioTracks"
QT_MOC_LITERAL(22, 280, 20), // "OpticalNumDataTracks"
QT_MOC_LITERAL(23, 301, 18), // "OpticalNumSessions"
QT_MOC_LITERAL(24, 320, 16), // "OpticalNumTracks"
QT_MOC_LITERAL(25, 337, 9), // "Removable"
QT_MOC_LITERAL(26, 347, 8), // "Revision"
QT_MOC_LITERAL(27, 356, 12), // "RotationRate"
QT_MOC_LITERAL(28, 369, 4), // "Seat"
QT_MOC_LITERAL(29, 374, 6), // "Serial"
QT_MOC_LITERAL(30, 381, 9), // "SiblingId"
QT_MOC_LITERAL(31, 391, 4), // "Size"
QT_MOC_LITERAL(32, 396, 7), // "SortKey"
QT_MOC_LITERAL(33, 404, 12), // "TimeDetected"
QT_MOC_LITERAL(34, 417, 17), // "TimeMediaDetected"
QT_MOC_LITERAL(35, 435, 6), // "Vendor"
QT_MOC_LITERAL(36, 442, 3) // "WWN"

    },
    "OrgFreedesktopUDisks2DriveInterface\0"
    "Eject\0QDBusPendingReply<>\0\0options\0"
    "PowerOff\0SetConfiguration\0value\0"
    "CanPowerOff\0Configuration\0ConnectionBus\0"
    "Ejectable\0Id\0Media\0MediaAvailable\0"
    "MediaChangeDetected\0MediaCompatibility\0"
    "MediaRemovable\0Model\0Optical\0OpticalBlank\0"
    "OpticalNumAudioTracks\0OpticalNumDataTracks\0"
    "OpticalNumSessions\0OpticalNumTracks\0"
    "Removable\0Revision\0RotationRate\0Seat\0"
    "Serial\0SiblingId\0Size\0SortKey\0"
    "TimeDetected\0TimeMediaDetected\0Vendor\0"
    "WWN"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_OrgFreedesktopUDisks2DriveInterface[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       3,   14, // methods
      29,   40, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   29,    3, 0x0a /* Public */,
       5,    1,   32,    3, 0x0a /* Public */,
       6,    2,   35,    3, 0x0a /* Public */,

 // slots: parameters
    0x80000000 | 2, QMetaType::QVariantMap,    4,
    0x80000000 | 2, QMetaType::QVariantMap,    4,
    0x80000000 | 2, QMetaType::QVariantMap, QMetaType::QVariantMap,    7,    4,

 // properties: name, type, flags
       8, QMetaType::Bool, 0x00095001,
       9, QMetaType::QVariantMap, 0x00095001,
      10, QMetaType::QString, 0x00095001,
      11, QMetaType::Bool, 0x00095001,
      12, QMetaType::QString, 0x00095001,
      13, QMetaType::QString, 0x00095001,
      14, QMetaType::Bool, 0x00095001,
      15, QMetaType::Bool, 0x00095001,
      16, QMetaType::QStringList, 0x00095001,
      17, QMetaType::Bool, 0x00095001,
      18, QMetaType::QString, 0x00095001,
      19, QMetaType::Bool, 0x00095001,
      20, QMetaType::Bool, 0x00095001,
      21, QMetaType::UInt, 0x00095001,
      22, QMetaType::UInt, 0x00095001,
      23, QMetaType::UInt, 0x00095001,
      24, QMetaType::UInt, 0x00095001,
      25, QMetaType::Bool, 0x00095001,
      26, QMetaType::QString, 0x00095001,
      27, QMetaType::Int, 0x00095001,
      28, QMetaType::QString, 0x00095001,
      29, QMetaType::QString, 0x00095001,
      30, QMetaType::QString, 0x00095001,
      31, QMetaType::ULongLong, 0x00095001,
      32, QMetaType::QString, 0x00095001,
      33, QMetaType::ULongLong, 0x00095001,
      34, QMetaType::ULongLong, 0x00095001,
      35, QMetaType::QString, 0x00095001,
      36, QMetaType::QString, 0x00095001,

       0        // eod
};

void OrgFreedesktopUDisks2DriveInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<OrgFreedesktopUDisks2DriveInterface *>(_o);
        (void)_t;
        switch (_id) {
        case 0: { QDBusPendingReply<> _r = _t->Eject((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 1: { QDBusPendingReply<> _r = _t->PowerOff((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 2: { QDBusPendingReply<> _r = _t->SetConfiguration((*reinterpret_cast< const QVariantMap(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<OrgFreedesktopUDisks2DriveInterface *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< bool*>(_v) = _t->canPowerOff(); break;
        case 1: *reinterpret_cast< QVariantMap*>(_v) = _t->configuration(); break;
        case 2: *reinterpret_cast< QString*>(_v) = _t->connectionBus(); break;
        case 3: *reinterpret_cast< bool*>(_v) = _t->ejectable(); break;
        case 4: *reinterpret_cast< QString*>(_v) = _t->id(); break;
        case 5: *reinterpret_cast< QString*>(_v) = _t->media(); break;
        case 6: *reinterpret_cast< bool*>(_v) = _t->mediaAvailable(); break;
        case 7: *reinterpret_cast< bool*>(_v) = _t->mediaChangeDetected(); break;
        case 8: *reinterpret_cast< QStringList*>(_v) = _t->mediaCompatibility(); break;
        case 9: *reinterpret_cast< bool*>(_v) = _t->mediaRemovable(); break;
        case 10: *reinterpret_cast< QString*>(_v) = _t->model(); break;
        case 11: *reinterpret_cast< bool*>(_v) = _t->optical(); break;
        case 12: *reinterpret_cast< bool*>(_v) = _t->opticalBlank(); break;
        case 13: *reinterpret_cast< uint*>(_v) = _t->opticalNumAudioTracks(); break;
        case 14: *reinterpret_cast< uint*>(_v) = _t->opticalNumDataTracks(); break;
        case 15: *reinterpret_cast< uint*>(_v) = _t->opticalNumSessions(); break;
        case 16: *reinterpret_cast< uint*>(_v) = _t->opticalNumTracks(); break;
        case 17: *reinterpret_cast< bool*>(_v) = _t->removable(); break;
        case 18: *reinterpret_cast< QString*>(_v) = _t->revision(); break;
        case 19: *reinterpret_cast< int*>(_v) = _t->rotationRate(); break;
        case 20: *reinterpret_cast< QString*>(_v) = _t->seat(); break;
        case 21: *reinterpret_cast< QString*>(_v) = _t->serial(); break;
        case 22: *reinterpret_cast< QString*>(_v) = _t->siblingId(); break;
        case 23: *reinterpret_cast< qulonglong*>(_v) = _t->size(); break;
        case 24: *reinterpret_cast< QString*>(_v) = _t->sortKey(); break;
        case 25: *reinterpret_cast< qulonglong*>(_v) = _t->timeDetected(); break;
        case 26: *reinterpret_cast< qulonglong*>(_v) = _t->timeMediaDetected(); break;
        case 27: *reinterpret_cast< QString*>(_v) = _t->vendor(); break;
        case 28: *reinterpret_cast< QString*>(_v) = _t->wWN(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

QT_INIT_METAOBJECT const QMetaObject OrgFreedesktopUDisks2DriveInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
    qt_meta_stringdata_OrgFreedesktopUDisks2DriveInterface.data,
    qt_meta_data_OrgFreedesktopUDisks2DriveInterface,
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *OrgFreedesktopUDisks2DriveInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *OrgFreedesktopUDisks2DriveInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_OrgFreedesktopUDisks2DriveInterface.stringdata0))
        return static_cast<void*>(this);
    return QDBusAbstractInterface::qt_metacast(_clname);
}

int OrgFreedesktopUDisks2DriveInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 3;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 29;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 29;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 29;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 29;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 29;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 29;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
struct qt_meta_stringdata_OrgFreedesktopUDisks2DriveAtaInterface_t {
    QByteArrayData data[42];
    char stringdata0[759];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_OrgFreedesktopUDisks2DriveAtaInterface_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_OrgFreedesktopUDisks2DriveAtaInterface_t qt_meta_stringdata_OrgFreedesktopUDisks2DriveAtaInterface = {
    {
QT_MOC_LITERAL(0, 0, 38), // "OrgFreedesktopUDisks2DriveAta..."
QT_MOC_LITERAL(1, 39, 10), // "PmGetState"
QT_MOC_LITERAL(2, 50, 24), // "QDBusPendingReply<uchar>"
QT_MOC_LITERAL(3, 75, 0), // ""
QT_MOC_LITERAL(4, 76, 7), // "options"
QT_MOC_LITERAL(5, 84, 9), // "PmStandby"
QT_MOC_LITERAL(6, 94, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(7, 114, 8), // "PmWakeup"
QT_MOC_LITERAL(8, 123, 17), // "SecurityEraseUnit"
QT_MOC_LITERAL(9, 141, 18), // "SmartGetAttributes"
QT_MOC_LITERAL(10, 160, 50), // "QDBusPendingReply<QList<UDisk..."
QT_MOC_LITERAL(11, 211, 18), // "SmartSelftestAbort"
QT_MOC_LITERAL(12, 230, 18), // "SmartSelftestStart"
QT_MOC_LITERAL(13, 249, 4), // "type"
QT_MOC_LITERAL(14, 254, 15), // "SmartSetEnabled"
QT_MOC_LITERAL(15, 270, 5), // "value"
QT_MOC_LITERAL(16, 276, 11), // "SmartUpdate"
QT_MOC_LITERAL(17, 288, 10), // "AamEnabled"
QT_MOC_LITERAL(18, 299, 12), // "AamSupported"
QT_MOC_LITERAL(19, 312, 25), // "AamVendorRecommendedValue"
QT_MOC_LITERAL(20, 338, 10), // "ApmEnabled"
QT_MOC_LITERAL(21, 349, 12), // "ApmSupported"
QT_MOC_LITERAL(22, 362, 9), // "PmEnabled"
QT_MOC_LITERAL(23, 372, 11), // "PmSupported"
QT_MOC_LITERAL(24, 384, 20), // "ReadLookaheadEnabled"
QT_MOC_LITERAL(25, 405, 22), // "ReadLookaheadSupported"
QT_MOC_LITERAL(26, 428, 32), // "SecurityEnhancedEraseUnitMinutes"
QT_MOC_LITERAL(27, 461, 24), // "SecurityEraseUnitMinutes"
QT_MOC_LITERAL(28, 486, 14), // "SecurityFrozen"
QT_MOC_LITERAL(29, 501, 12), // "SmartEnabled"
QT_MOC_LITERAL(30, 514, 12), // "SmartFailing"
QT_MOC_LITERAL(31, 527, 33), // "SmartNumAttributesFailedInThe..."
QT_MOC_LITERAL(32, 561, 25), // "SmartNumAttributesFailing"
QT_MOC_LITERAL(33, 587, 18), // "SmartNumBadSectors"
QT_MOC_LITERAL(34, 606, 19), // "SmartPowerOnSeconds"
QT_MOC_LITERAL(35, 626, 29), // "SmartSelftestPercentRemaining"
QT_MOC_LITERAL(36, 656, 19), // "SmartSelftestStatus"
QT_MOC_LITERAL(37, 676, 14), // "SmartSupported"
QT_MOC_LITERAL(38, 691, 16), // "SmartTemperature"
QT_MOC_LITERAL(39, 708, 12), // "SmartUpdated"
QT_MOC_LITERAL(40, 721, 17), // "WriteCacheEnabled"
QT_MOC_LITERAL(41, 739, 19) // "WriteCacheSupported"

    },
    "OrgFreedesktopUDisks2DriveAtaInterface\0"
    "PmGetState\0QDBusPendingReply<uchar>\0"
    "\0options\0PmStandby\0QDBusPendingReply<>\0"
    "PmWakeup\0SecurityEraseUnit\0"
    "SmartGetAttributes\0"
    "QDBusPendingReply<QList<UDisks2::SmartAttribute> >\0"
    "SmartSelftestAbort\0SmartSelftestStart\0"
    "type\0SmartSetEnabled\0value\0SmartUpdate\0"
    "AamEnabled\0AamSupported\0"
    "AamVendorRecommendedValue\0ApmEnabled\0"
    "ApmSupported\0PmEnabled\0PmSupported\0"
    "ReadLookaheadEnabled\0ReadLookaheadSupported\0"
    "SecurityEnhancedEraseUnitMinutes\0"
    "SecurityEraseUnitMinutes\0SecurityFrozen\0"
    "SmartEnabled\0SmartFailing\0"
    "SmartNumAttributesFailedInThePast\0"
    "SmartNumAttributesFailing\0SmartNumBadSectors\0"
    "SmartPowerOnSeconds\0SmartSelftestPercentRemaining\0"
    "SmartSelftestStatus\0SmartSupported\0"
    "SmartTemperature\0SmartUpdated\0"
    "WriteCacheEnabled\0WriteCacheSupported"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_OrgFreedesktopUDisks2DriveAtaInterface[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       9,   14, // methods
      25,   90, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   59,    3, 0x0a /* Public */,
       5,    1,   62,    3, 0x0a /* Public */,
       7,    1,   65,    3, 0x0a /* Public */,
       8,    1,   68,    3, 0x0a /* Public */,
       9,    1,   71,    3, 0x0a /* Public */,
      11,    1,   74,    3, 0x0a /* Public */,
      12,    2,   77,    3, 0x0a /* Public */,
      14,    2,   82,    3, 0x0a /* Public */,
      16,    1,   87,    3, 0x0a /* Public */,

 // slots: parameters
    0x80000000 | 2, QMetaType::QVariantMap,    4,
    0x80000000 | 6, QMetaType::QVariantMap,    4,
    0x80000000 | 6, QMetaType::QVariantMap,    4,
    0x80000000 | 6, QMetaType::QVariantMap,    4,
    0x80000000 | 10, QMetaType::QVariantMap,    4,
    0x80000000 | 6, QMetaType::QVariantMap,    4,
    0x80000000 | 6, QMetaType::QString, QMetaType::QVariantMap,   13,    4,
    0x80000000 | 6, QMetaType::Bool, QMetaType::QVariantMap,   15,    4,
    0x80000000 | 6, QMetaType::QVariantMap,    4,

 // properties: name, type, flags
      17, QMetaType::Bool, 0x00095001,
      18, QMetaType::Bool, 0x00095001,
      19, QMetaType::Int, 0x00095001,
      20, QMetaType::Bool, 0x00095001,
      21, QMetaType::Bool, 0x00095001,
      22, QMetaType::Bool, 0x00095001,
      23, QMetaType::Bool, 0x00095001,
      24, QMetaType::Bool, 0x00095001,
      25, QMetaType::Bool, 0x00095001,
      26, QMetaType::Int, 0x00095001,
      27, QMetaType::Int, 0x00095001,
      28, QMetaType::Bool, 0x00095001,
      29, QMetaType::Bool, 0x00095001,
      30, QMetaType::Bool, 0x00095001,
      31, QMetaType::Int, 0x00095001,
      32, QMetaType::Int, 0x00095001,
      33, QMetaType::LongLong, 0x00095001,
      34, QMetaType::ULongLong, 0x00095001,
      35, QMetaType::Int, 0x00095001,
      36, QMetaType::QString, 0x00095001,
      37, QMetaType::Bool, 0x00095001,
      38, QMetaType::Double, 0x00095001,
      39, QMetaType::ULongLong, 0x00095001,
      40, QMetaType::Bool, 0x00095001,
      41, QMetaType::Bool, 0x00095001,

       0        // eod
};

void OrgFreedesktopUDisks2DriveAtaInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<OrgFreedesktopUDisks2DriveAtaInterface *>(_o);
        (void)_t;
        switch (_id) {
        case 0: { QDBusPendingReply<uchar> _r = _t->PmGetState((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<uchar>*>(_a[0]) = std::move(_r); }  break;
        case 1: { QDBusPendingReply<> _r = _t->PmStandby((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 2: { QDBusPendingReply<> _r = _t->PmWakeup((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 3: { QDBusPendingReply<> _r = _t->SecurityEraseUnit((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 4: { QDBusPendingReply<QList<UDisks2::SmartAttribute> > _r = _t->SmartGetAttributes((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QList<UDisks2::SmartAttribute> >*>(_a[0]) = std::move(_r); }  break;
        case 5: { QDBusPendingReply<> _r = _t->SmartSelftestAbort((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 6: { QDBusPendingReply<> _r = _t->SmartSelftestStart((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 7: { QDBusPendingReply<> _r = _t->SmartSetEnabled((*reinterpret_cast< bool(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 8: { QDBusPendingReply<> _r = _t->SmartUpdate((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<OrgFreedesktopUDisks2DriveAtaInterface *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< bool*>(_v) = _t->aamEnabled(); break;
        case 1: *reinterpret_cast< bool*>(_v) = _t->aamSupported(); break;
        case 2: *reinterpret_cast< int*>(_v) = _t->aamVendorRecommendedValue(); break;
        case 3: *reinterpret_cast< bool*>(_v) = _t->apmEnabled(); break;
        case 4: *reinterpret_cast< bool*>(_v) = _t->apmSupported(); break;
        case 5: *reinterpret_cast< bool*>(_v) = _t->pmEnabled(); break;
        case 6: *reinterpret_cast< bool*>(_v) = _t->pmSupported(); break;
        case 7: *reinterpret_cast< bool*>(_v) = _t->readLookaheadEnabled(); break;
        case 8: *reinterpret_cast< bool*>(_v) = _t->readLookaheadSupported(); break;
        case 9: *reinterpret_cast< int*>(_v) = _t->securityEnhancedEraseUnitMinutes(); break;
        case 10: *reinterpret_cast< int*>(_v) = _t->securityEraseUnitMinutes(); break;
        case 11: *reinterpret_cast< bool*>(_v) = _t->securityFrozen(); break;
        case 12: *reinterpret_cast< bool*>(_v) = _t->smartEnabled(); break;
        case 13: *reinterpret_cast< bool*>(_v) = _t->smartFailing(); break;
        case 14: *reinterpret_cast< int*>(_v) = _t->smartNumAttributesFailedInThePast(); break;
        case 15: *reinterpret_cast< int*>(_v) = _t->smartNumAttributesFailing(); break;
        case 16: *reinterpret_cast< qlonglong*>(_v) = _t->smartNumBadSectors(); break;
        case 17: *reinterpret_cast< qulonglong*>(_v) = _t->smartPowerOnSeconds(); break;
        case 18: *reinterpret_cast< int*>(_v) = _t->smartSelftestPercentRemaining(); break;
        case 19: *reinterpret_cast< QString*>(_v) = _t->smartSelftestStatus(); break;
        case 20: *reinterpret_cast< bool*>(_v) = _t->smartSupported(); break;
        case 21: *reinterpret_cast< double*>(_v) = _t->smartTemperature(); break;
        case 22: *reinterpret_cast< qulonglong*>(_v) = _t->smartUpdated(); break;
        case 23: *reinterpret_cast< bool*>(_v) = _t->writeCacheEnabled(); break;
        case 24: *reinterpret_cast< bool*>(_v) = _t->writeCacheSupported(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

QT_INIT_METAOBJECT const QMetaObject OrgFreedesktopUDisks2DriveAtaInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
    qt_meta_stringdata_OrgFreedesktopUDisks2DriveAtaInterface.data,
    qt_meta_data_OrgFreedesktopUDisks2DriveAtaInterface,
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *OrgFreedesktopUDisks2DriveAtaInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *OrgFreedesktopUDisks2DriveAtaInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_OrgFreedesktopUDisks2DriveAtaInterface.stringdata0))
        return static_cast<void*>(this);
    return QDBusAbstractInterface::qt_metacast(_clname);
}

int OrgFreedesktopUDisks2DriveAtaInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 9)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 9;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 9)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 9;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 25;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 25;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
struct qt_meta_stringdata_OrgFreedesktopUDisks2EncryptedInterface_t {
    QByteArrayData data[18];
    char stringdata0[289];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_OrgFreedesktopUDisks2EncryptedInterface_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_OrgFreedesktopUDisks2EncryptedInterface_t qt_meta_stringdata_OrgFreedesktopUDisks2EncryptedInterface = {
    {
QT_MOC_LITERAL(0, 0, 39), // "OrgFreedesktopUDisks2Encrypte..."
QT_MOC_LITERAL(1, 40, 16), // "ChangePassphrase"
QT_MOC_LITERAL(2, 57, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(3, 77, 0), // ""
QT_MOC_LITERAL(4, 78, 10), // "passphrase"
QT_MOC_LITERAL(5, 89, 14), // "new_passphrase"
QT_MOC_LITERAL(6, 104, 7), // "options"
QT_MOC_LITERAL(7, 112, 4), // "Lock"
QT_MOC_LITERAL(8, 117, 6), // "Resize"
QT_MOC_LITERAL(9, 124, 4), // "size"
QT_MOC_LITERAL(10, 129, 6), // "Unlock"
QT_MOC_LITERAL(11, 136, 34), // "QDBusPendingReply<QDBusObject..."
QT_MOC_LITERAL(12, 171, 18), // "ChildConfiguration"
QT_MOC_LITERAL(13, 190, 34), // "QList<QPair<QString,QVariantM..."
QT_MOC_LITERAL(14, 225, 15), // "CleartextDevice"
QT_MOC_LITERAL(15, 241, 15), // "QDBusObjectPath"
QT_MOC_LITERAL(16, 257, 18), // "HintEncryptionType"
QT_MOC_LITERAL(17, 276, 12) // "MetadataSize"

    },
    "OrgFreedesktopUDisks2EncryptedInterface\0"
    "ChangePassphrase\0QDBusPendingReply<>\0"
    "\0passphrase\0new_passphrase\0options\0"
    "Lock\0Resize\0size\0Unlock\0"
    "QDBusPendingReply<QDBusObjectPath>\0"
    "ChildConfiguration\0"
    "QList<QPair<QString,QVariantMap> >\0"
    "CleartextDevice\0QDBusObjectPath\0"
    "HintEncryptionType\0MetadataSize"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_OrgFreedesktopUDisks2EncryptedInterface[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       4,   14, // methods
       4,   54, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    3,   34,    3, 0x0a /* Public */,
       7,    1,   41,    3, 0x0a /* Public */,
       8,    2,   44,    3, 0x0a /* Public */,
      10,    2,   49,    3, 0x0a /* Public */,

 // slots: parameters
    0x80000000 | 2, QMetaType::QString, QMetaType::QString, QMetaType::QVariantMap,    4,    5,    6,
    0x80000000 | 2, QMetaType::QVariantMap,    6,
    0x80000000 | 2, QMetaType::ULongLong, QMetaType::QVariantMap,    9,    6,
    0x80000000 | 11, QMetaType::QString, QMetaType::QVariantMap,    4,    6,

 // properties: name, type, flags
      12, 0x80000000 | 13, 0x00095009,
      14, 0x80000000 | 15, 0x00095009,
      16, QMetaType::QString, 0x00095001,
      17, QMetaType::ULongLong, 0x00095001,

       0        // eod
};

void OrgFreedesktopUDisks2EncryptedInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<OrgFreedesktopUDisks2EncryptedInterface *>(_o);
        (void)_t;
        switch (_id) {
        case 0: { QDBusPendingReply<> _r = _t->ChangePassphrase((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QVariantMap(*)>(_a[3])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 1: { QDBusPendingReply<> _r = _t->Lock((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 2: { QDBusPendingReply<> _r = _t->Resize((*reinterpret_cast< qulonglong(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 3: { QDBusPendingReply<QDBusObjectPath> _r = _t->Unlock((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 1:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusObjectPath >(); break;
        }
    }

#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<OrgFreedesktopUDisks2EncryptedInterface *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QList<QPair<QString,QVariantMap> >*>(_v) = _t->childConfiguration(); break;
        case 1: *reinterpret_cast< QDBusObjectPath*>(_v) = _t->cleartextDevice(); break;
        case 2: *reinterpret_cast< QString*>(_v) = _t->hintEncryptionType(); break;
        case 3: *reinterpret_cast< qulonglong*>(_v) = _t->metadataSize(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

QT_INIT_METAOBJECT const QMetaObject OrgFreedesktopUDisks2EncryptedInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
    qt_meta_stringdata_OrgFreedesktopUDisks2EncryptedInterface.data,
    qt_meta_data_OrgFreedesktopUDisks2EncryptedInterface,
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *OrgFreedesktopUDisks2EncryptedInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *OrgFreedesktopUDisks2EncryptedInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_OrgFreedesktopUDisks2EncryptedInterface.stringdata0))
        return static_cast<void*>(this);
    return QDBusAbstractInterface::qt_metacast(_clname);
}

int OrgFreedesktopUDisks2EncryptedInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 4)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 4)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 4;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 4;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 4;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 4;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 4;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 4;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
struct qt_meta_stringdata_OrgFreedesktopUDisks2FilesystemInterface_t {
    QByteArrayData data[17];
    char stringdata0[206];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_OrgFreedesktopUDisks2FilesystemInterface_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_OrgFreedesktopUDisks2FilesystemInterface_t qt_meta_stringdata_OrgFreedesktopUDisks2FilesystemInterface = {
    {
QT_MOC_LITERAL(0, 0, 40), // "OrgFreedesktopUDisks2Filesyst..."
QT_MOC_LITERAL(1, 41, 5), // "Check"
QT_MOC_LITERAL(2, 47, 23), // "QDBusPendingReply<bool>"
QT_MOC_LITERAL(3, 71, 0), // ""
QT_MOC_LITERAL(4, 72, 7), // "options"
QT_MOC_LITERAL(5, 80, 5), // "Mount"
QT_MOC_LITERAL(6, 86, 26), // "QDBusPendingReply<QString>"
QT_MOC_LITERAL(7, 113, 6), // "Repair"
QT_MOC_LITERAL(8, 120, 6), // "Resize"
QT_MOC_LITERAL(9, 127, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(10, 147, 4), // "size"
QT_MOC_LITERAL(11, 152, 8), // "SetLabel"
QT_MOC_LITERAL(12, 161, 5), // "label"
QT_MOC_LITERAL(13, 167, 13), // "TakeOwnership"
QT_MOC_LITERAL(14, 181, 7), // "Unmount"
QT_MOC_LITERAL(15, 189, 11), // "MountPoints"
QT_MOC_LITERAL(16, 201, 4) // "Size"

    },
    "OrgFreedesktopUDisks2FilesystemInterface\0"
    "Check\0QDBusPendingReply<bool>\0\0options\0"
    "Mount\0QDBusPendingReply<QString>\0"
    "Repair\0Resize\0QDBusPendingReply<>\0"
    "size\0SetLabel\0label\0TakeOwnership\0"
    "Unmount\0MountPoints\0Size"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_OrgFreedesktopUDisks2FilesystemInterface[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       7,   14, // methods
       2,   74, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   49,    3, 0x0a /* Public */,
       5,    1,   52,    3, 0x0a /* Public */,
       7,    1,   55,    3, 0x0a /* Public */,
       8,    2,   58,    3, 0x0a /* Public */,
      11,    2,   63,    3, 0x0a /* Public */,
      13,    1,   68,    3, 0x0a /* Public */,
      14,    1,   71,    3, 0x0a /* Public */,

 // slots: parameters
    0x80000000 | 2, QMetaType::QVariantMap,    4,
    0x80000000 | 6, QMetaType::QVariantMap,    4,
    0x80000000 | 2, QMetaType::QVariantMap,    4,
    0x80000000 | 9, QMetaType::ULongLong, QMetaType::QVariantMap,   10,    4,
    0x80000000 | 9, QMetaType::QString, QMetaType::QVariantMap,   12,    4,
    0x80000000 | 9, QMetaType::QVariantMap,    4,
    0x80000000 | 9, QMetaType::QVariantMap,    4,

 // properties: name, type, flags
      15, QMetaType::QByteArrayList, 0x00095001,
      16, QMetaType::ULongLong, 0x00095001,

       0        // eod
};

void OrgFreedesktopUDisks2FilesystemInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<OrgFreedesktopUDisks2FilesystemInterface *>(_o);
        (void)_t;
        switch (_id) {
        case 0: { QDBusPendingReply<bool> _r = _t->Check((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<bool>*>(_a[0]) = std::move(_r); }  break;
        case 1: { QDBusPendingReply<QString> _r = _t->Mount((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 2: { QDBusPendingReply<bool> _r = _t->Repair((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<bool>*>(_a[0]) = std::move(_r); }  break;
        case 3: { QDBusPendingReply<> _r = _t->Resize((*reinterpret_cast< qulonglong(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 4: { QDBusPendingReply<> _r = _t->SetLabel((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 5: { QDBusPendingReply<> _r = _t->TakeOwnership((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 6: { QDBusPendingReply<> _r = _t->Unmount((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<OrgFreedesktopUDisks2FilesystemInterface *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QByteArrayList*>(_v) = _t->mountPoints(); break;
        case 1: *reinterpret_cast< qulonglong*>(_v) = _t->size(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

QT_INIT_METAOBJECT const QMetaObject OrgFreedesktopUDisks2FilesystemInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
    qt_meta_stringdata_OrgFreedesktopUDisks2FilesystemInterface.data,
    qt_meta_data_OrgFreedesktopUDisks2FilesystemInterface,
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *OrgFreedesktopUDisks2FilesystemInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *OrgFreedesktopUDisks2FilesystemInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_OrgFreedesktopUDisks2FilesystemInterface.stringdata0))
        return static_cast<void*>(this);
    return QDBusAbstractInterface::qt_metacast(_clname);
}

int OrgFreedesktopUDisks2FilesystemInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 7)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 7;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 7)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 7;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 2;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 2;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 2;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 2;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 2;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
struct qt_meta_stringdata_OrgFreedesktopUDisks2JobInterface_t {
    QByteArrayData data[19];
    char stringdata0[221];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_OrgFreedesktopUDisks2JobInterface_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_OrgFreedesktopUDisks2JobInterface_t qt_meta_stringdata_OrgFreedesktopUDisks2JobInterface = {
    {
QT_MOC_LITERAL(0, 0, 33), // "OrgFreedesktopUDisks2JobInter..."
QT_MOC_LITERAL(1, 34, 9), // "Completed"
QT_MOC_LITERAL(2, 44, 0), // ""
QT_MOC_LITERAL(3, 45, 7), // "success"
QT_MOC_LITERAL(4, 53, 7), // "message"
QT_MOC_LITERAL(5, 61, 6), // "Cancel"
QT_MOC_LITERAL(6, 68, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(7, 88, 7), // "options"
QT_MOC_LITERAL(8, 96, 5), // "Bytes"
QT_MOC_LITERAL(9, 102, 10), // "Cancelable"
QT_MOC_LITERAL(10, 113, 15), // "ExpectedEndTime"
QT_MOC_LITERAL(11, 129, 7), // "Objects"
QT_MOC_LITERAL(12, 137, 22), // "QList<QDBusObjectPath>"
QT_MOC_LITERAL(13, 160, 9), // "Operation"
QT_MOC_LITERAL(14, 170, 8), // "Progress"
QT_MOC_LITERAL(15, 179, 13), // "ProgressValid"
QT_MOC_LITERAL(16, 193, 4), // "Rate"
QT_MOC_LITERAL(17, 198, 9), // "StartTime"
QT_MOC_LITERAL(18, 208, 12) // "StartedByUID"

    },
    "OrgFreedesktopUDisks2JobInterface\0"
    "Completed\0\0success\0message\0Cancel\0"
    "QDBusPendingReply<>\0options\0Bytes\0"
    "Cancelable\0ExpectedEndTime\0Objects\0"
    "QList<QDBusObjectPath>\0Operation\0"
    "Progress\0ProgressValid\0Rate\0StartTime\0"
    "StartedByUID"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_OrgFreedesktopUDisks2JobInterface[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
      10,   32, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       1,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    2,   24,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
       5,    1,   29,    2, 0x0a /* Public */,

 // signals: parameters
    QMetaType::Void, QMetaType::Bool, QMetaType::QString,    3,    4,

 // slots: parameters
    0x80000000 | 6, QMetaType::QVariantMap,    7,

 // properties: name, type, flags
       8, QMetaType::ULongLong, 0x00095001,
       9, QMetaType::Bool, 0x00095001,
      10, QMetaType::ULongLong, 0x00095001,
      11, 0x80000000 | 12, 0x00095009,
      13, QMetaType::QString, 0x00095001,
      14, QMetaType::Double, 0x00095001,
      15, QMetaType::Bool, 0x00095001,
      16, QMetaType::ULongLong, 0x00095001,
      17, QMetaType::ULongLong, 0x00095001,
      18, QMetaType::UInt, 0x00095001,

       0        // eod
};

void OrgFreedesktopUDisks2JobInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<OrgFreedesktopUDisks2JobInterface *>(_o);
        (void)_t;
        switch (_id) {
        case 0: _t->Completed((*reinterpret_cast< bool(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2]))); break;
        case 1: { QDBusPendingReply<> _r = _t->Cancel((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    } else if (_c == QMetaObject::IndexOfMethod) {
        int *result = reinterpret_cast<int *>(_a[0]);
        {
            using _t = void (OrgFreedesktopUDisks2JobInterface::*)(bool , const QString & );
            if (*reinterpret_cast<_t *>(_a[1]) == static_cast<_t>(&OrgFreedesktopUDisks2JobInterface::Completed)) {
                *result = 0;
                return;
            }
        }
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 3:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<QDBusObjectPath> >(); break;
        }
    }

#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<OrgFreedesktopUDisks2JobInterface *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< qulonglong*>(_v) = _t->bytes(); break;
        case 1: *reinterpret_cast< bool*>(_v) = _t->cancelable(); break;
        case 2: *reinterpret_cast< qulonglong*>(_v) = _t->expectedEndTime(); break;
        case 3: *reinterpret_cast< QList<QDBusObjectPath>*>(_v) = _t->objects(); break;
        case 4: *reinterpret_cast< QString*>(_v) = _t->operation(); break;
        case 5: *reinterpret_cast< double*>(_v) = _t->progress(); break;
        case 6: *reinterpret_cast< bool*>(_v) = _t->progressValid(); break;
        case 7: *reinterpret_cast< qulonglong*>(_v) = _t->rate(); break;
        case 8: *reinterpret_cast< qulonglong*>(_v) = _t->startTime(); break;
        case 9: *reinterpret_cast< uint*>(_v) = _t->startedByUID(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

QT_INIT_METAOBJECT const QMetaObject OrgFreedesktopUDisks2JobInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
    qt_meta_stringdata_OrgFreedesktopUDisks2JobInterface.data,
    qt_meta_data_OrgFreedesktopUDisks2JobInterface,
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *OrgFreedesktopUDisks2JobInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *OrgFreedesktopUDisks2JobInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_OrgFreedesktopUDisks2JobInterface.stringdata0))
        return static_cast<void*>(this);
    return QDBusAbstractInterface::qt_metacast(_clname);
}

int OrgFreedesktopUDisks2JobInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 10;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}

// SIGNAL 0
void OrgFreedesktopUDisks2JobInterface::Completed(bool _t1, const QString & _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}
struct qt_meta_stringdata_OrgFreedesktopUDisks2LoopInterface_t {
    QByteArrayData data[10];
    char stringdata0[123];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_OrgFreedesktopUDisks2LoopInterface_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_OrgFreedesktopUDisks2LoopInterface_t qt_meta_stringdata_OrgFreedesktopUDisks2LoopInterface = {
    {
QT_MOC_LITERAL(0, 0, 34), // "OrgFreedesktopUDisks2LoopInte..."
QT_MOC_LITERAL(1, 35, 6), // "Delete"
QT_MOC_LITERAL(2, 42, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(3, 62, 0), // ""
QT_MOC_LITERAL(4, 63, 7), // "options"
QT_MOC_LITERAL(5, 71, 12), // "SetAutoclear"
QT_MOC_LITERAL(6, 84, 5), // "value"
QT_MOC_LITERAL(7, 90, 9), // "Autoclear"
QT_MOC_LITERAL(8, 100, 11), // "BackingFile"
QT_MOC_LITERAL(9, 112, 10) // "SetupByUID"

    },
    "OrgFreedesktopUDisks2LoopInterface\0"
    "Delete\0QDBusPendingReply<>\0\0options\0"
    "SetAutoclear\0value\0Autoclear\0BackingFile\0"
    "SetupByUID"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_OrgFreedesktopUDisks2LoopInterface[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       3,   32, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   24,    3, 0x0a /* Public */,
       5,    2,   27,    3, 0x0a /* Public */,

 // slots: parameters
    0x80000000 | 2, QMetaType::QVariantMap,    4,
    0x80000000 | 2, QMetaType::Bool, QMetaType::QVariantMap,    6,    4,

 // properties: name, type, flags
       7, QMetaType::Bool, 0x00095001,
       8, QMetaType::QByteArray, 0x00095001,
       9, QMetaType::UInt, 0x00095001,

       0        // eod
};

void OrgFreedesktopUDisks2LoopInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<OrgFreedesktopUDisks2LoopInterface *>(_o);
        (void)_t;
        switch (_id) {
        case 0: { QDBusPendingReply<> _r = _t->Delete((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 1: { QDBusPendingReply<> _r = _t->SetAutoclear((*reinterpret_cast< bool(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<OrgFreedesktopUDisks2LoopInterface *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< bool*>(_v) = _t->autoclear(); break;
        case 1: *reinterpret_cast< QByteArray*>(_v) = _t->backingFile(); break;
        case 2: *reinterpret_cast< uint*>(_v) = _t->setupByUID(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

QT_INIT_METAOBJECT const QMetaObject OrgFreedesktopUDisks2LoopInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
    qt_meta_stringdata_OrgFreedesktopUDisks2LoopInterface.data,
    qt_meta_data_OrgFreedesktopUDisks2LoopInterface,
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *OrgFreedesktopUDisks2LoopInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *OrgFreedesktopUDisks2LoopInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_OrgFreedesktopUDisks2LoopInterface.stringdata0))
        return static_cast<void*>(this);
    return QDBusAbstractInterface::qt_metacast(_clname);
}

int OrgFreedesktopUDisks2LoopInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 3;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 3;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
struct qt_meta_stringdata_OrgFreedesktopUDisks2MDRaidInterface_t {
    QByteArrayData data[32];
    char stringdata0[411];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_OrgFreedesktopUDisks2MDRaidInterface_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_OrgFreedesktopUDisks2MDRaidInterface_t qt_meta_stringdata_OrgFreedesktopUDisks2MDRaidInterface = {
    {
QT_MOC_LITERAL(0, 0, 36), // "OrgFreedesktopUDisks2MDRaidIn..."
QT_MOC_LITERAL(1, 37, 9), // "AddDevice"
QT_MOC_LITERAL(2, 47, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(3, 67, 0), // ""
QT_MOC_LITERAL(4, 68, 15), // "QDBusObjectPath"
QT_MOC_LITERAL(5, 84, 6), // "device"
QT_MOC_LITERAL(6, 91, 7), // "options"
QT_MOC_LITERAL(7, 99, 6), // "Delete"
QT_MOC_LITERAL(8, 106, 12), // "RemoveDevice"
QT_MOC_LITERAL(9, 119, 17), // "RequestSyncAction"
QT_MOC_LITERAL(10, 137, 11), // "sync_action"
QT_MOC_LITERAL(11, 149, 17), // "SetBitmapLocation"
QT_MOC_LITERAL(12, 167, 5), // "value"
QT_MOC_LITERAL(13, 173, 5), // "Start"
QT_MOC_LITERAL(14, 179, 4), // "Stop"
QT_MOC_LITERAL(15, 184, 13), // "ActiveDevices"
QT_MOC_LITERAL(16, 198, 32), // "QList<UDisks2::ActiveDeviceInfo>"
QT_MOC_LITERAL(17, 231, 14), // "BitmapLocation"
QT_MOC_LITERAL(18, 246, 18), // "ChildConfiguration"
QT_MOC_LITERAL(19, 265, 34), // "QList<QPair<QString,QVariantM..."
QT_MOC_LITERAL(20, 300, 9), // "ChunkSize"
QT_MOC_LITERAL(21, 310, 8), // "Degraded"
QT_MOC_LITERAL(22, 319, 5), // "Level"
QT_MOC_LITERAL(23, 325, 4), // "Name"
QT_MOC_LITERAL(24, 330, 10), // "NumDevices"
QT_MOC_LITERAL(25, 341, 7), // "Running"
QT_MOC_LITERAL(26, 349, 4), // "Size"
QT_MOC_LITERAL(27, 354, 10), // "SyncAction"
QT_MOC_LITERAL(28, 365, 13), // "SyncCompleted"
QT_MOC_LITERAL(29, 379, 8), // "SyncRate"
QT_MOC_LITERAL(30, 388, 17), // "SyncRemainingTime"
QT_MOC_LITERAL(31, 406, 4) // "UUID"

    },
    "OrgFreedesktopUDisks2MDRaidInterface\0"
    "AddDevice\0QDBusPendingReply<>\0\0"
    "QDBusObjectPath\0device\0options\0Delete\0"
    "RemoveDevice\0RequestSyncAction\0"
    "sync_action\0SetBitmapLocation\0value\0"
    "Start\0Stop\0ActiveDevices\0"
    "QList<UDisks2::ActiveDeviceInfo>\0"
    "BitmapLocation\0ChildConfiguration\0"
    "QList<QPair<QString,QVariantMap> >\0"
    "ChunkSize\0Degraded\0Level\0Name\0NumDevices\0"
    "Running\0Size\0SyncAction\0SyncCompleted\0"
    "SyncRate\0SyncRemainingTime\0UUID"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_OrgFreedesktopUDisks2MDRaidInterface[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       7,   14, // methods
      15,   78, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    2,   49,    3, 0x0a /* Public */,
       7,    1,   54,    3, 0x0a /* Public */,
       8,    2,   57,    3, 0x0a /* Public */,
       9,    2,   62,    3, 0x0a /* Public */,
      11,    2,   67,    3, 0x0a /* Public */,
      13,    1,   72,    3, 0x0a /* Public */,
      14,    1,   75,    3, 0x0a /* Public */,

 // slots: parameters
    0x80000000 | 2, 0x80000000 | 4, QMetaType::QVariantMap,    5,    6,
    0x80000000 | 2, QMetaType::QVariantMap,    6,
    0x80000000 | 2, 0x80000000 | 4, QMetaType::QVariantMap,    5,    6,
    0x80000000 | 2, QMetaType::QString, QMetaType::QVariantMap,   10,    6,
    0x80000000 | 2, QMetaType::QByteArray, QMetaType::QVariantMap,   12,    6,
    0x80000000 | 2, QMetaType::QVariantMap,    6,
    0x80000000 | 2, QMetaType::QVariantMap,    6,

 // properties: name, type, flags
      15, 0x80000000 | 16, 0x00095009,
      17, QMetaType::QByteArray, 0x00095001,
      18, 0x80000000 | 19, 0x00095009,
      20, QMetaType::ULongLong, 0x00095001,
      21, QMetaType::UInt, 0x00095001,
      22, QMetaType::QString, 0x00095001,
      23, QMetaType::QString, 0x00095001,
      24, QMetaType::UInt, 0x00095001,
      25, QMetaType::Bool, 0x00095001,
      26, QMetaType::ULongLong, 0x00095001,
      27, QMetaType::QString, 0x00095001,
      28, QMetaType::Double, 0x00095001,
      29, QMetaType::ULongLong, 0x00095001,
      30, QMetaType::ULongLong, 0x00095001,
      31, QMetaType::QString, 0x00095001,

       0        // eod
};

void OrgFreedesktopUDisks2MDRaidInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<OrgFreedesktopUDisks2MDRaidInterface *>(_o);
        (void)_t;
        switch (_id) {
        case 0: { QDBusPendingReply<> _r = _t->AddDevice((*reinterpret_cast< const QDBusObjectPath(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 1: { QDBusPendingReply<> _r = _t->Delete((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 2: { QDBusPendingReply<> _r = _t->RemoveDevice((*reinterpret_cast< const QDBusObjectPath(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 3: { QDBusPendingReply<> _r = _t->RequestSyncAction((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 4: { QDBusPendingReply<> _r = _t->SetBitmapLocation((*reinterpret_cast< const QByteArray(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 5: { QDBusPendingReply<> _r = _t->Start((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 6: { QDBusPendingReply<> _r = _t->Stop((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusObjectPath >(); break;
            }
            break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusObjectPath >(); break;
            }
            break;
        }
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<UDisks2::ActiveDeviceInfo> >(); break;
        }
    }

#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<OrgFreedesktopUDisks2MDRaidInterface *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QList<UDisks2::ActiveDeviceInfo>*>(_v) = _t->activeDevices(); break;
        case 1: *reinterpret_cast< QByteArray*>(_v) = _t->bitmapLocation(); break;
        case 2: *reinterpret_cast< QList<QPair<QString,QVariantMap> >*>(_v) = _t->childConfiguration(); break;
        case 3: *reinterpret_cast< qulonglong*>(_v) = _t->chunkSize(); break;
        case 4: *reinterpret_cast< uint*>(_v) = _t->degraded(); break;
        case 5: *reinterpret_cast< QString*>(_v) = _t->level(); break;
        case 6: *reinterpret_cast< QString*>(_v) = _t->name(); break;
        case 7: *reinterpret_cast< uint*>(_v) = _t->numDevices(); break;
        case 8: *reinterpret_cast< bool*>(_v) = _t->running(); break;
        case 9: *reinterpret_cast< qulonglong*>(_v) = _t->size(); break;
        case 10: *reinterpret_cast< QString*>(_v) = _t->syncAction(); break;
        case 11: *reinterpret_cast< double*>(_v) = _t->syncCompleted(); break;
        case 12: *reinterpret_cast< qulonglong*>(_v) = _t->syncRate(); break;
        case 13: *reinterpret_cast< qulonglong*>(_v) = _t->syncRemainingTime(); break;
        case 14: *reinterpret_cast< QString*>(_v) = _t->uUID(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

QT_INIT_METAOBJECT const QMetaObject OrgFreedesktopUDisks2MDRaidInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
    qt_meta_stringdata_OrgFreedesktopUDisks2MDRaidInterface.data,
    qt_meta_data_OrgFreedesktopUDisks2MDRaidInterface,
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *OrgFreedesktopUDisks2MDRaidInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *OrgFreedesktopUDisks2MDRaidInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_OrgFreedesktopUDisks2MDRaidInterface.stringdata0))
        return static_cast<void*>(this);
    return QDBusAbstractInterface::qt_metacast(_clname);
}

int OrgFreedesktopUDisks2MDRaidInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 7)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 7;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 7)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 7;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 15;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 15;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 15;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 15;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 15;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 15;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
struct qt_meta_stringdata_OrgFreedesktopUDisks2ManagerInterface_t {
    QByteArrayData data[31];
    char stringdata0[517];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_OrgFreedesktopUDisks2ManagerInterface_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_OrgFreedesktopUDisks2ManagerInterface_t qt_meta_stringdata_OrgFreedesktopUDisks2ManagerInterface = {
    {
QT_MOC_LITERAL(0, 0, 37), // "OrgFreedesktopUDisks2ManagerI..."
QT_MOC_LITERAL(1, 38, 8), // "CanCheck"
QT_MOC_LITERAL(2, 47, 39), // "QDBusPendingReply<QPair<bool,..."
QT_MOC_LITERAL(3, 87, 0), // ""
QT_MOC_LITERAL(4, 88, 4), // "type"
QT_MOC_LITERAL(5, 93, 9), // "CanFormat"
QT_MOC_LITERAL(6, 103, 9), // "CanRepair"
QT_MOC_LITERAL(7, 113, 9), // "CanResize"
QT_MOC_LITERAL(8, 123, 55), // "QDBusPendingReply<QPair<bool,..."
QT_MOC_LITERAL(9, 179, 13), // "EnableModules"
QT_MOC_LITERAL(10, 193, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(11, 213, 6), // "enable"
QT_MOC_LITERAL(12, 220, 15), // "GetBlockDevices"
QT_MOC_LITERAL(13, 236, 42), // "QDBusPendingReply<QList<QDBus..."
QT_MOC_LITERAL(14, 279, 7), // "options"
QT_MOC_LITERAL(15, 287, 9), // "LoopSetup"
QT_MOC_LITERAL(16, 297, 34), // "QDBusPendingReply<QDBusObject..."
QT_MOC_LITERAL(17, 332, 23), // "QDBusUnixFileDescriptor"
QT_MOC_LITERAL(18, 356, 2), // "fd"
QT_MOC_LITERAL(19, 359, 12), // "MDRaidCreate"
QT_MOC_LITERAL(20, 372, 22), // "QList<QDBusObjectPath>"
QT_MOC_LITERAL(21, 395, 6), // "blocks"
QT_MOC_LITERAL(22, 402, 5), // "level"
QT_MOC_LITERAL(23, 408, 4), // "name"
QT_MOC_LITERAL(24, 413, 5), // "chunk"
QT_MOC_LITERAL(25, 419, 13), // "ResolveDevice"
QT_MOC_LITERAL(26, 433, 7), // "devspec"
QT_MOC_LITERAL(27, 441, 21), // "DefaultEncryptionType"
QT_MOC_LITERAL(28, 463, 24), // "SupportedEncryptionTypes"
QT_MOC_LITERAL(29, 488, 20), // "SupportedFilesystems"
QT_MOC_LITERAL(30, 509, 7) // "Version"

    },
    "OrgFreedesktopUDisks2ManagerInterface\0"
    "CanCheck\0QDBusPendingReply<QPair<bool,QString> >\0"
    "\0type\0CanFormat\0CanRepair\0CanResize\0"
    "QDBusPendingReply<QPair<bool,QPair<quint64,QString> > >\0"
    "EnableModules\0QDBusPendingReply<>\0"
    "enable\0GetBlockDevices\0"
    "QDBusPendingReply<QList<QDBusObjectPath> >\0"
    "options\0LoopSetup\0QDBusPendingReply<QDBusObjectPath>\0"
    "QDBusUnixFileDescriptor\0fd\0MDRaidCreate\0"
    "QList<QDBusObjectPath>\0blocks\0level\0"
    "name\0chunk\0ResolveDevice\0devspec\0"
    "DefaultEncryptionType\0SupportedEncryptionTypes\0"
    "SupportedFilesystems\0Version"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_OrgFreedesktopUDisks2ManagerInterface[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       9,   14, // methods
       4,   98, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   59,    3, 0x0a /* Public */,
       5,    1,   62,    3, 0x0a /* Public */,
       6,    1,   65,    3, 0x0a /* Public */,
       7,    1,   68,    3, 0x0a /* Public */,
       9,    1,   71,    3, 0x0a /* Public */,
      12,    1,   74,    3, 0x0a /* Public */,
      15,    2,   77,    3, 0x0a /* Public */,
      19,    5,   82,    3, 0x0a /* Public */,
      25,    2,   93,    3, 0x0a /* Public */,

 // slots: parameters
    0x80000000 | 2, QMetaType::QString,    4,
    0x80000000 | 2, QMetaType::QString,    4,
    0x80000000 | 2, QMetaType::QString,    4,
    0x80000000 | 8, QMetaType::QString,    4,
    0x80000000 | 10, QMetaType::Bool,   11,
    0x80000000 | 13, QMetaType::QVariantMap,   14,
    0x80000000 | 16, 0x80000000 | 17, QMetaType::QVariantMap,   18,   14,
    0x80000000 | 16, 0x80000000 | 20, QMetaType::QString, QMetaType::QString, QMetaType::ULongLong, QMetaType::QVariantMap,   21,   22,   23,   24,   14,
    0x80000000 | 13, QMetaType::QVariantMap, QMetaType::QVariantMap,   26,   14,

 // properties: name, type, flags
      27, QMetaType::QString, 0x00095001,
      28, QMetaType::QStringList, 0x00095001,
      29, QMetaType::QStringList, 0x00095001,
      30, QMetaType::QString, 0x00095001,

       0        // eod
};

void OrgFreedesktopUDisks2ManagerInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<OrgFreedesktopUDisks2ManagerInterface *>(_o);
        (void)_t;
        switch (_id) {
        case 0: { QDBusPendingReply<QPair<bool,QString> > _r = _t->CanCheck((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QPair<bool,QString> >*>(_a[0]) = std::move(_r); }  break;
        case 1: { QDBusPendingReply<QPair<bool,QString> > _r = _t->CanFormat((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QPair<bool,QString> >*>(_a[0]) = std::move(_r); }  break;
        case 2: { QDBusPendingReply<QPair<bool,QString> > _r = _t->CanRepair((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QPair<bool,QString> >*>(_a[0]) = std::move(_r); }  break;
        case 3: { QDBusPendingReply<QPair<bool,QPair<quint64,QString> > > _r = _t->CanResize((*reinterpret_cast< const QString(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QPair<bool,QPair<quint64,QString> > >*>(_a[0]) = std::move(_r); }  break;
        case 4: { QDBusPendingReply<> _r = _t->EnableModules((*reinterpret_cast< bool(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 5: { QDBusPendingReply<QList<QDBusObjectPath> > _r = _t->GetBlockDevices((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QList<QDBusObjectPath> >*>(_a[0]) = std::move(_r); }  break;
        case 6: { QDBusPendingReply<QDBusObjectPath> _r = _t->LoopSetup((*reinterpret_cast< const QDBusUnixFileDescriptor(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 7: { QDBusPendingReply<QDBusObjectPath> _r = _t->MDRaidCreate((*reinterpret_cast< const QList<QDBusObjectPath>(*)>(_a[1])),(*reinterpret_cast< const QString(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3])),(*reinterpret_cast< qulonglong(*)>(_a[4])),(*reinterpret_cast< const QVariantMap(*)>(_a[5])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 8: { QDBusPendingReply<QList<QDBusObjectPath> > _r = _t->ResolveDevice((*reinterpret_cast< const QVariantMap(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QList<QDBusObjectPath> >*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusUnixFileDescriptor >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<int*>(_a[0]) = -1; break;
            case 0:
                *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<QDBusObjectPath> >(); break;
            }
            break;
        }
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<OrgFreedesktopUDisks2ManagerInterface *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QString*>(_v) = _t->defaultEncryptionType(); break;
        case 1: *reinterpret_cast< QStringList*>(_v) = _t->supportedEncryptionTypes(); break;
        case 2: *reinterpret_cast< QStringList*>(_v) = _t->supportedFilesystems(); break;
        case 3: *reinterpret_cast< QString*>(_v) = _t->version(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

QT_INIT_METAOBJECT const QMetaObject OrgFreedesktopUDisks2ManagerInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
    qt_meta_stringdata_OrgFreedesktopUDisks2ManagerInterface.data,
    qt_meta_data_OrgFreedesktopUDisks2ManagerInterface,
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *OrgFreedesktopUDisks2ManagerInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *OrgFreedesktopUDisks2ManagerInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_OrgFreedesktopUDisks2ManagerInterface.stringdata0))
        return static_cast<void*>(this);
    return QDBusAbstractInterface::qt_metacast(_clname);
}

int OrgFreedesktopUDisks2ManagerInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 9)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 9;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 9)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 9;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 4;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 4;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 4;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 4;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 4;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
struct qt_meta_stringdata_OrgFreedesktopUDisks2PartitionInterface_t {
    QByteArrayData data[24];
    char stringdata0[215];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_OrgFreedesktopUDisks2PartitionInterface_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_OrgFreedesktopUDisks2PartitionInterface_t qt_meta_stringdata_OrgFreedesktopUDisks2PartitionInterface = {
    {
QT_MOC_LITERAL(0, 0, 39), // "OrgFreedesktopUDisks2Partitio..."
QT_MOC_LITERAL(1, 40, 6), // "Delete"
QT_MOC_LITERAL(2, 47, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(3, 67, 0), // ""
QT_MOC_LITERAL(4, 68, 7), // "options"
QT_MOC_LITERAL(5, 76, 6), // "Resize"
QT_MOC_LITERAL(6, 83, 4), // "size"
QT_MOC_LITERAL(7, 88, 8), // "SetFlags"
QT_MOC_LITERAL(8, 97, 5), // "flags"
QT_MOC_LITERAL(9, 103, 7), // "SetName"
QT_MOC_LITERAL(10, 111, 4), // "name"
QT_MOC_LITERAL(11, 116, 7), // "SetType"
QT_MOC_LITERAL(12, 124, 4), // "type"
QT_MOC_LITERAL(13, 129, 5), // "Flags"
QT_MOC_LITERAL(14, 135, 11), // "IsContained"
QT_MOC_LITERAL(15, 147, 11), // "IsContainer"
QT_MOC_LITERAL(16, 159, 4), // "Name"
QT_MOC_LITERAL(17, 164, 6), // "Number"
QT_MOC_LITERAL(18, 171, 6), // "Offset"
QT_MOC_LITERAL(19, 178, 4), // "Size"
QT_MOC_LITERAL(20, 183, 5), // "Table"
QT_MOC_LITERAL(21, 189, 15), // "QDBusObjectPath"
QT_MOC_LITERAL(22, 205, 4), // "Type"
QT_MOC_LITERAL(23, 210, 4) // "UUID"

    },
    "OrgFreedesktopUDisks2PartitionInterface\0"
    "Delete\0QDBusPendingReply<>\0\0options\0"
    "Resize\0size\0SetFlags\0flags\0SetName\0"
    "name\0SetType\0type\0Flags\0IsContained\0"
    "IsContainer\0Name\0Number\0Offset\0Size\0"
    "Table\0QDBusObjectPath\0Type\0UUID"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_OrgFreedesktopUDisks2PartitionInterface[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       5,   14, // methods
      10,   62, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    1,   39,    3, 0x0a /* Public */,
       5,    2,   42,    3, 0x0a /* Public */,
       7,    2,   47,    3, 0x0a /* Public */,
       9,    2,   52,    3, 0x0a /* Public */,
      11,    2,   57,    3, 0x0a /* Public */,

 // slots: parameters
    0x80000000 | 2, QMetaType::QVariantMap,    4,
    0x80000000 | 2, QMetaType::ULongLong, QMetaType::QVariantMap,    6,    4,
    0x80000000 | 2, QMetaType::ULongLong, QMetaType::QVariantMap,    8,    4,
    0x80000000 | 2, QMetaType::QString, QMetaType::QVariantMap,   10,    4,
    0x80000000 | 2, QMetaType::QString, QMetaType::QVariantMap,   12,    4,

 // properties: name, type, flags
      13, QMetaType::ULongLong, 0x00095001,
      14, QMetaType::Bool, 0x00095001,
      15, QMetaType::Bool, 0x00095001,
      16, QMetaType::QString, 0x00095001,
      17, QMetaType::UInt, 0x00095001,
      18, QMetaType::ULongLong, 0x00095001,
      19, QMetaType::ULongLong, 0x00095001,
      20, 0x80000000 | 21, 0x00095009,
      22, QMetaType::QString, 0x00095001,
      23, QMetaType::QString, 0x00095001,

       0        // eod
};

void OrgFreedesktopUDisks2PartitionInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<OrgFreedesktopUDisks2PartitionInterface *>(_o);
        (void)_t;
        switch (_id) {
        case 0: { QDBusPendingReply<> _r = _t->Delete((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 1: { QDBusPendingReply<> _r = _t->Resize((*reinterpret_cast< qulonglong(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 2: { QDBusPendingReply<> _r = _t->SetFlags((*reinterpret_cast< qulonglong(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 3: { QDBusPendingReply<> _r = _t->SetName((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 4: { QDBusPendingReply<> _r = _t->SetType((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 7:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusObjectPath >(); break;
        }
    }

#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<OrgFreedesktopUDisks2PartitionInterface *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< qulonglong*>(_v) = _t->flags(); break;
        case 1: *reinterpret_cast< bool*>(_v) = _t->isContained(); break;
        case 2: *reinterpret_cast< bool*>(_v) = _t->isContainer(); break;
        case 3: *reinterpret_cast< QString*>(_v) = _t->name(); break;
        case 4: *reinterpret_cast< uint*>(_v) = _t->number(); break;
        case 5: *reinterpret_cast< qulonglong*>(_v) = _t->offset(); break;
        case 6: *reinterpret_cast< qulonglong*>(_v) = _t->size(); break;
        case 7: *reinterpret_cast< QDBusObjectPath*>(_v) = _t->table(); break;
        case 8: *reinterpret_cast< QString*>(_v) = _t->type(); break;
        case 9: *reinterpret_cast< QString*>(_v) = _t->uUID(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

QT_INIT_METAOBJECT const QMetaObject OrgFreedesktopUDisks2PartitionInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
    qt_meta_stringdata_OrgFreedesktopUDisks2PartitionInterface.data,
    qt_meta_data_OrgFreedesktopUDisks2PartitionInterface,
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *OrgFreedesktopUDisks2PartitionInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *OrgFreedesktopUDisks2PartitionInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_OrgFreedesktopUDisks2PartitionInterface.stringdata0))
        return static_cast<void*>(this);
    return QDBusAbstractInterface::qt_metacast(_clname);
}

int OrgFreedesktopUDisks2PartitionInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 5;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 10;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 10;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
struct qt_meta_stringdata_OrgFreedesktopUDisks2PartitionTableInterface_t {
    QByteArrayData data[15];
    char stringdata0[218];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_OrgFreedesktopUDisks2PartitionTableInterface_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_OrgFreedesktopUDisks2PartitionTableInterface_t qt_meta_stringdata_OrgFreedesktopUDisks2PartitionTableInterface = {
    {
QT_MOC_LITERAL(0, 0, 44), // "OrgFreedesktopUDisks2Partitio..."
QT_MOC_LITERAL(1, 45, 15), // "CreatePartition"
QT_MOC_LITERAL(2, 61, 34), // "QDBusPendingReply<QDBusObject..."
QT_MOC_LITERAL(3, 96, 0), // ""
QT_MOC_LITERAL(4, 97, 6), // "offset"
QT_MOC_LITERAL(5, 104, 4), // "size"
QT_MOC_LITERAL(6, 109, 4), // "type"
QT_MOC_LITERAL(7, 114, 4), // "name"
QT_MOC_LITERAL(8, 119, 7), // "options"
QT_MOC_LITERAL(9, 127, 24), // "CreatePartitionAndFormat"
QT_MOC_LITERAL(10, 152, 11), // "format_type"
QT_MOC_LITERAL(11, 164, 14), // "format_options"
QT_MOC_LITERAL(12, 179, 10), // "Partitions"
QT_MOC_LITERAL(13, 190, 22), // "QList<QDBusObjectPath>"
QT_MOC_LITERAL(14, 213, 4) // "Type"

    },
    "OrgFreedesktopUDisks2PartitionTableInterface\0"
    "CreatePartition\0QDBusPendingReply<QDBusObjectPath>\0"
    "\0offset\0size\0type\0name\0options\0"
    "CreatePartitionAndFormat\0format_type\0"
    "format_options\0Partitions\0"
    "QList<QDBusObjectPath>\0Type"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_OrgFreedesktopUDisks2PartitionTableInterface[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       2,   14, // methods
       2,   50, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    5,   24,    3, 0x0a /* Public */,
       9,    7,   35,    3, 0x0a /* Public */,

 // slots: parameters
    0x80000000 | 2, QMetaType::ULongLong, QMetaType::ULongLong, QMetaType::QString, QMetaType::QString, QMetaType::QVariantMap,    4,    5,    6,    7,    8,
    0x80000000 | 2, QMetaType::ULongLong, QMetaType::ULongLong, QMetaType::QString, QMetaType::QString, QMetaType::QVariantMap, QMetaType::QString, QMetaType::QVariantMap,    4,    5,    6,    7,    8,   10,   11,

 // properties: name, type, flags
      12, 0x80000000 | 13, 0x00095009,
      14, QMetaType::QString, 0x00095001,

       0        // eod
};

void OrgFreedesktopUDisks2PartitionTableInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<OrgFreedesktopUDisks2PartitionTableInterface *>(_o);
        (void)_t;
        switch (_id) {
        case 0: { QDBusPendingReply<QDBusObjectPath> _r = _t->CreatePartition((*reinterpret_cast< qulonglong(*)>(_a[1])),(*reinterpret_cast< qulonglong(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3])),(*reinterpret_cast< const QString(*)>(_a[4])),(*reinterpret_cast< const QVariantMap(*)>(_a[5])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 1: { QDBusPendingReply<QDBusObjectPath> _r = _t->CreatePartitionAndFormat((*reinterpret_cast< qulonglong(*)>(_a[1])),(*reinterpret_cast< qulonglong(*)>(_a[2])),(*reinterpret_cast< const QString(*)>(_a[3])),(*reinterpret_cast< const QString(*)>(_a[4])),(*reinterpret_cast< const QVariantMap(*)>(_a[5])),(*reinterpret_cast< const QString(*)>(_a[6])),(*reinterpret_cast< const QVariantMap(*)>(_a[7])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    } else if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<QDBusObjectPath> >(); break;
        }
    }

#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<OrgFreedesktopUDisks2PartitionTableInterface *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< QList<QDBusObjectPath>*>(_v) = _t->partitions(); break;
        case 1: *reinterpret_cast< QString*>(_v) = _t->type(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

QT_INIT_METAOBJECT const QMetaObject OrgFreedesktopUDisks2PartitionTableInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
    qt_meta_stringdata_OrgFreedesktopUDisks2PartitionTableInterface.data,
    qt_meta_data_OrgFreedesktopUDisks2PartitionTableInterface,
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *OrgFreedesktopUDisks2PartitionTableInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *OrgFreedesktopUDisks2PartitionTableInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_OrgFreedesktopUDisks2PartitionTableInterface.stringdata0))
        return static_cast<void*>(this);
    return QDBusAbstractInterface::qt_metacast(_clname);
}

int OrgFreedesktopUDisks2PartitionTableInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 2;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 2;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 2;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 2;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 2;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 2;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
struct qt_meta_stringdata_OrgFreedesktopUDisks2SwapspaceInterface_t {
    QByteArrayData data[9];
    char stringdata0[102];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_OrgFreedesktopUDisks2SwapspaceInterface_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_OrgFreedesktopUDisks2SwapspaceInterface_t qt_meta_stringdata_OrgFreedesktopUDisks2SwapspaceInterface = {
    {
QT_MOC_LITERAL(0, 0, 39), // "OrgFreedesktopUDisks2Swapspac..."
QT_MOC_LITERAL(1, 40, 8), // "SetLabel"
QT_MOC_LITERAL(2, 49, 19), // "QDBusPendingReply<>"
QT_MOC_LITERAL(3, 69, 0), // ""
QT_MOC_LITERAL(4, 70, 5), // "label"
QT_MOC_LITERAL(5, 76, 7), // "options"
QT_MOC_LITERAL(6, 84, 5), // "Start"
QT_MOC_LITERAL(7, 90, 4), // "Stop"
QT_MOC_LITERAL(8, 95, 6) // "Active"

    },
    "OrgFreedesktopUDisks2SwapspaceInterface\0"
    "SetLabel\0QDBusPendingReply<>\0\0label\0"
    "options\0Start\0Stop\0Active"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_OrgFreedesktopUDisks2SwapspaceInterface[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
       3,   14, // methods
       1,   40, // properties
       0,    0, // enums/sets
       0,    0, // constructors
       0,       // flags
       0,       // signalCount

 // slots: name, argc, parameters, tag, flags
       1,    2,   29,    3, 0x0a /* Public */,
       6,    1,   34,    3, 0x0a /* Public */,
       7,    1,   37,    3, 0x0a /* Public */,

 // slots: parameters
    0x80000000 | 2, QMetaType::QString, QMetaType::QVariantMap,    4,    5,
    0x80000000 | 2, QMetaType::QVariantMap,    5,
    0x80000000 | 2, QMetaType::QVariantMap,    5,

 // properties: name, type, flags
       8, QMetaType::Bool, 0x00095001,

       0        // eod
};

void OrgFreedesktopUDisks2SwapspaceInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    if (_c == QMetaObject::InvokeMetaMethod) {
        auto *_t = static_cast<OrgFreedesktopUDisks2SwapspaceInterface *>(_o);
        (void)_t;
        switch (_id) {
        case 0: { QDBusPendingReply<> _r = _t->SetLabel((*reinterpret_cast< const QString(*)>(_a[1])),(*reinterpret_cast< const QVariantMap(*)>(_a[2])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 1: { QDBusPendingReply<> _r = _t->Start((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 2: { QDBusPendingReply<> _r = _t->Stop((*reinterpret_cast< const QVariantMap(*)>(_a[1])));
            if (_a[0]) *reinterpret_cast< QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty) {
        auto *_t = static_cast<OrgFreedesktopUDisks2SwapspaceInterface *>(_o);
        (void)_t;
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast< bool*>(_v) = _t->active(); break;
        default: break;
        }
    } else if (_c == QMetaObject::WriteProperty) {
    } else if (_c == QMetaObject::ResetProperty) {
    }
#endif // QT_NO_PROPERTIES
}

QT_INIT_METAOBJECT const QMetaObject OrgFreedesktopUDisks2SwapspaceInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
    qt_meta_stringdata_OrgFreedesktopUDisks2SwapspaceInterface.data,
    qt_meta_data_OrgFreedesktopUDisks2SwapspaceInterface,
    qt_static_metacall,
    nullptr,
    nullptr
} };


const QMetaObject *OrgFreedesktopUDisks2SwapspaceInterface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *OrgFreedesktopUDisks2SwapspaceInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_meta_stringdata_OrgFreedesktopUDisks2SwapspaceInterface.stringdata0))
        return static_cast<void*>(this);
    return QDBusAbstractInterface::qt_metacast(_clname);
}

int OrgFreedesktopUDisks2SwapspaceInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QDBusAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<int*>(_a[0]) = -1;
        _id -= 3;
    }
#ifndef QT_NO_PROPERTIES
    else if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyDesignable) {
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyScriptable) {
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyStored) {
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyEditable) {
        _id -= 1;
    } else if (_c == QMetaObject::QueryPropertyUser) {
        _id -= 1;
    }
#endif // QT_NO_PROPERTIES
    return _id;
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
