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

#include "unitinterface.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


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

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN35OrgFreedesktopSystemd1UnitInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto OrgFreedesktopSystemd1UnitInterface::qt_create_metaobjectdata<qt_meta_tag_ZN35OrgFreedesktopSystemd1UnitInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "OrgFreedesktopSystemd1UnitInterface",
        "Kill",
        "QDBusPendingReply<>",
        "",
        "in0",
        "in1",
        "Ref",
        "Reload",
        "QDBusPendingReply<QDBusObjectPath>",
        "ReloadOrRestart",
        "ReloadOrTryRestart",
        "ResetFailed",
        "Restart",
        "Start",
        "Stop",
        "TryRestart",
        "Unref",
        "ActiveEnterTimestamp",
        "ActiveEnterTimestampMonotonic",
        "ActiveExitTimestamp",
        "ActiveExitTimestampMonotonic",
        "ActiveState",
        "After",
        "AllowIsolate",
        "AssertResult",
        "AssertTimestamp",
        "AssertTimestampMonotonic",
        "Before",
        "BindsTo",
        "BoundBy",
        "CanIsolate",
        "CanReload",
        "CanStart",
        "CanStop",
        "ConditionResult",
        "ConditionTimestamp",
        "ConditionTimestampMonotonic",
        "ConflictedBy",
        "Conflicts",
        "ConsistsOf",
        "DefaultDependencies",
        "Description",
        "Documentation",
        "DropInPaths",
        "Following",
        "FragmentPath",
        "Id",
        "IgnoreOnIsolate",
        "InactiveEnterTimestamp",
        "InactiveEnterTimestampMonotonic",
        "InactiveExitTimestamp",
        "InactiveExitTimestampMonotonic",
        "InvocationID",
        "JobTimeoutAction",
        "JobTimeoutRebootArgument",
        "JobTimeoutUSec",
        "JoinsNamespaceOf",
        "LoadState",
        "Names",
        "NeedDaemonReload",
        "OnFailure",
        "OnFailureJobMode",
        "PartOf",
        "Perpetual",
        "PropagatesReloadTo",
        "RebootArgument",
        "RefuseManualStart",
        "RefuseManualStop",
        "ReloadPropagatedFrom",
        "RequiredBy",
        "RequiresMountsFor",
        "Requisite",
        "RequisiteOf",
        "SourcePath",
        "StartLimitAction",
        "StartLimitBurst",
        "StartLimitIntervalSec",
        "StateChangeTimestamp",
        "StateChangeTimestampMonotonic",
        "StopWhenUnneeded",
        "SubState",
        "Transient",
        "TriggeredBy",
        "Triggers",
        "UnitFilePreset",
        "UnitFileState",
        "WantedBy",
        "Wants"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'Kill'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &, int)>(1, 3, QMC::AccessPublic, 0x80000000 | 2, {{
            { QMetaType::QString, 4 }, { QMetaType::Int, 5 },
        }}),
        // Slot 'Ref'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(6, 3, QMC::AccessPublic, 0x80000000 | 2),
        // Slot 'Reload'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &)>(7, 3, QMC::AccessPublic, 0x80000000 | 8, {{
            { QMetaType::QString, 4 },
        }}),
        // Slot 'ReloadOrRestart'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &)>(9, 3, QMC::AccessPublic, 0x80000000 | 8, {{
            { QMetaType::QString, 4 },
        }}),
        // Slot 'ReloadOrTryRestart'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &)>(10, 3, QMC::AccessPublic, 0x80000000 | 8, {{
            { QMetaType::QString, 4 },
        }}),
        // Slot 'ResetFailed'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(11, 3, QMC::AccessPublic, 0x80000000 | 2),
        // Slot 'Restart'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &)>(12, 3, QMC::AccessPublic, 0x80000000 | 8, {{
            { QMetaType::QString, 4 },
        }}),
        // Slot 'Start'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &)>(13, 3, QMC::AccessPublic, 0x80000000 | 8, {{
            { QMetaType::QString, 4 },
        }}),
        // Slot 'Stop'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &)>(14, 3, QMC::AccessPublic, 0x80000000 | 8, {{
            { QMetaType::QString, 4 },
        }}),
        // Slot 'TryRestart'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &)>(15, 3, QMC::AccessPublic, 0x80000000 | 8, {{
            { QMetaType::QString, 4 },
        }}),
        // Slot 'Unref'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(16, 3, QMC::AccessPublic, 0x80000000 | 2),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'ActiveEnterTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(17, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'ActiveEnterTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(18, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'ActiveExitTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(19, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'ActiveExitTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(20, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'ActiveState'
        QtMocHelpers::PropertyData<QString>(21, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'After'
        QtMocHelpers::PropertyData<QStringList>(22, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'AllowIsolate'
        QtMocHelpers::PropertyData<bool>(23, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'AssertResult'
        QtMocHelpers::PropertyData<bool>(24, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'AssertTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(25, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'AssertTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(26, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'Before'
        QtMocHelpers::PropertyData<QStringList>(27, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'BindsTo'
        QtMocHelpers::PropertyData<QStringList>(28, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'BoundBy'
        QtMocHelpers::PropertyData<QStringList>(29, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'CanIsolate'
        QtMocHelpers::PropertyData<bool>(30, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'CanReload'
        QtMocHelpers::PropertyData<bool>(31, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'CanStart'
        QtMocHelpers::PropertyData<bool>(32, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'CanStop'
        QtMocHelpers::PropertyData<bool>(33, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'ConditionResult'
        QtMocHelpers::PropertyData<bool>(34, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'ConditionTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(35, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'ConditionTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(36, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'ConflictedBy'
        QtMocHelpers::PropertyData<QStringList>(37, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'Conflicts'
        QtMocHelpers::PropertyData<QStringList>(38, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'ConsistsOf'
        QtMocHelpers::PropertyData<QStringList>(39, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'DefaultDependencies'
        QtMocHelpers::PropertyData<bool>(40, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'Description'
        QtMocHelpers::PropertyData<QString>(41, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'Documentation'
        QtMocHelpers::PropertyData<QStringList>(42, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'DropInPaths'
        QtMocHelpers::PropertyData<QStringList>(43, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'Following'
        QtMocHelpers::PropertyData<QString>(44, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'FragmentPath'
        QtMocHelpers::PropertyData<QString>(45, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'Id'
        QtMocHelpers::PropertyData<QString>(46, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'IgnoreOnIsolate'
        QtMocHelpers::PropertyData<bool>(47, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'InactiveEnterTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(48, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'InactiveEnterTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(49, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'InactiveExitTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(50, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'InactiveExitTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(51, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'InvocationID'
        QtMocHelpers::PropertyData<QByteArray>(52, QMetaType::QByteArray, QMC::DefaultPropertyFlags),
        // property 'JobTimeoutAction'
        QtMocHelpers::PropertyData<QString>(53, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'JobTimeoutRebootArgument'
        QtMocHelpers::PropertyData<QString>(54, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'JobTimeoutUSec'
        QtMocHelpers::PropertyData<qulonglong>(55, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'JoinsNamespaceOf'
        QtMocHelpers::PropertyData<QStringList>(56, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'LoadState'
        QtMocHelpers::PropertyData<QString>(57, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'Names'
        QtMocHelpers::PropertyData<QStringList>(58, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'NeedDaemonReload'
        QtMocHelpers::PropertyData<bool>(59, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'OnFailure'
        QtMocHelpers::PropertyData<QStringList>(60, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'OnFailureJobMode'
        QtMocHelpers::PropertyData<QString>(61, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'PartOf'
        QtMocHelpers::PropertyData<QStringList>(62, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'Perpetual'
        QtMocHelpers::PropertyData<bool>(63, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'PropagatesReloadTo'
        QtMocHelpers::PropertyData<QStringList>(64, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'RebootArgument'
        QtMocHelpers::PropertyData<QString>(65, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'RefuseManualStart'
        QtMocHelpers::PropertyData<bool>(66, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'RefuseManualStop'
        QtMocHelpers::PropertyData<bool>(67, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'ReloadPropagatedFrom'
        QtMocHelpers::PropertyData<QStringList>(68, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'RequiredBy'
        QtMocHelpers::PropertyData<QStringList>(69, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'RequiresMountsFor'
        QtMocHelpers::PropertyData<QStringList>(70, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'Requisite'
        QtMocHelpers::PropertyData<QStringList>(71, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'RequisiteOf'
        QtMocHelpers::PropertyData<QStringList>(72, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'SourcePath'
        QtMocHelpers::PropertyData<QString>(73, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'StartLimitAction'
        QtMocHelpers::PropertyData<QString>(74, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'StartLimitBurst'
        QtMocHelpers::PropertyData<uint>(75, QMetaType::UInt, QMC::DefaultPropertyFlags),
        // property 'StartLimitIntervalSec'
        QtMocHelpers::PropertyData<qulonglong>(76, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'StateChangeTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(77, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'StateChangeTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(78, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'StopWhenUnneeded'
        QtMocHelpers::PropertyData<bool>(79, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'SubState'
        QtMocHelpers::PropertyData<QString>(80, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'Transient'
        QtMocHelpers::PropertyData<bool>(81, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'TriggeredBy'
        QtMocHelpers::PropertyData<QStringList>(82, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'Triggers'
        QtMocHelpers::PropertyData<QStringList>(83, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'UnitFilePreset'
        QtMocHelpers::PropertyData<QString>(84, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'UnitFileState'
        QtMocHelpers::PropertyData<QString>(85, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'WantedBy'
        QtMocHelpers::PropertyData<QStringList>(86, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'Wants'
        QtMocHelpers::PropertyData<QStringList>(87, QMetaType::QStringList, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<OrgFreedesktopSystemd1UnitInterface, qt_meta_tag_ZN35OrgFreedesktopSystemd1UnitInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject OrgFreedesktopSystemd1UnitInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QDBusAbstractInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN35OrgFreedesktopSystemd1UnitInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN35OrgFreedesktopSystemd1UnitInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN35OrgFreedesktopSystemd1UnitInterfaceE_t>.metaTypes,
    nullptr
} };

void OrgFreedesktopSystemd1UnitInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<OrgFreedesktopSystemd1UnitInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QDBusPendingReply<> _r = _t->Kill((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 1: { QDBusPendingReply<> _r = _t->Ref();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 2: { QDBusPendingReply<QDBusObjectPath> _r = _t->Reload((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 3: { QDBusPendingReply<QDBusObjectPath> _r = _t->ReloadOrRestart((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 4: { QDBusPendingReply<QDBusObjectPath> _r = _t->ReloadOrTryRestart((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 5: { QDBusPendingReply<> _r = _t->ResetFailed();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 6: { QDBusPendingReply<QDBusObjectPath> _r = _t->Restart((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 7: { QDBusPendingReply<QDBusObjectPath> _r = _t->Start((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 8: { QDBusPendingReply<QDBusObjectPath> _r = _t->Stop((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 9: { QDBusPendingReply<QDBusObjectPath> _r = _t->TryRestart((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 10: { QDBusPendingReply<> _r = _t->Unref();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<qulonglong*>(_v) = _t->activeEnterTimestamp(); break;
        case 1: *reinterpret_cast<qulonglong*>(_v) = _t->activeEnterTimestampMonotonic(); break;
        case 2: *reinterpret_cast<qulonglong*>(_v) = _t->activeExitTimestamp(); break;
        case 3: *reinterpret_cast<qulonglong*>(_v) = _t->activeExitTimestampMonotonic(); break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->activeState(); break;
        case 5: *reinterpret_cast<QStringList*>(_v) = _t->after(); break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->allowIsolate(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->assertResult(); break;
        case 8: *reinterpret_cast<qulonglong*>(_v) = _t->assertTimestamp(); break;
        case 9: *reinterpret_cast<qulonglong*>(_v) = _t->assertTimestampMonotonic(); break;
        case 10: *reinterpret_cast<QStringList*>(_v) = _t->before(); break;
        case 11: *reinterpret_cast<QStringList*>(_v) = _t->bindsTo(); break;
        case 12: *reinterpret_cast<QStringList*>(_v) = _t->boundBy(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->canIsolate(); break;
        case 14: *reinterpret_cast<bool*>(_v) = _t->canReload(); break;
        case 15: *reinterpret_cast<bool*>(_v) = _t->canStart(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->canStop(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->conditionResult(); break;
        case 18: *reinterpret_cast<qulonglong*>(_v) = _t->conditionTimestamp(); break;
        case 19: *reinterpret_cast<qulonglong*>(_v) = _t->conditionTimestampMonotonic(); break;
        case 20: *reinterpret_cast<QStringList*>(_v) = _t->conflictedBy(); break;
        case 21: *reinterpret_cast<QStringList*>(_v) = _t->conflicts(); break;
        case 22: *reinterpret_cast<QStringList*>(_v) = _t->consistsOf(); break;
        case 23: *reinterpret_cast<bool*>(_v) = _t->defaultDependencies(); break;
        case 24: *reinterpret_cast<QString*>(_v) = _t->description(); break;
        case 25: *reinterpret_cast<QStringList*>(_v) = _t->documentation(); break;
        case 26: *reinterpret_cast<QStringList*>(_v) = _t->dropInPaths(); break;
        case 27: *reinterpret_cast<QString*>(_v) = _t->following(); break;
        case 28: *reinterpret_cast<QString*>(_v) = _t->fragmentPath(); break;
        case 29: *reinterpret_cast<QString*>(_v) = _t->id(); break;
        case 30: *reinterpret_cast<bool*>(_v) = _t->ignoreOnIsolate(); break;
        case 31: *reinterpret_cast<qulonglong*>(_v) = _t->inactiveEnterTimestamp(); break;
        case 32: *reinterpret_cast<qulonglong*>(_v) = _t->inactiveEnterTimestampMonotonic(); break;
        case 33: *reinterpret_cast<qulonglong*>(_v) = _t->inactiveExitTimestamp(); break;
        case 34: *reinterpret_cast<qulonglong*>(_v) = _t->inactiveExitTimestampMonotonic(); break;
        case 35: *reinterpret_cast<QByteArray*>(_v) = _t->invocationID(); break;
        case 36: *reinterpret_cast<QString*>(_v) = _t->jobTimeoutAction(); break;
        case 37: *reinterpret_cast<QString*>(_v) = _t->jobTimeoutRebootArgument(); break;
        case 38: *reinterpret_cast<qulonglong*>(_v) = _t->jobTimeoutUSec(); break;
        case 39: *reinterpret_cast<QStringList*>(_v) = _t->joinsNamespaceOf(); break;
        case 40: *reinterpret_cast<QString*>(_v) = _t->loadState(); break;
        case 41: *reinterpret_cast<QStringList*>(_v) = _t->names(); break;
        case 42: *reinterpret_cast<bool*>(_v) = _t->needDaemonReload(); break;
        case 43: *reinterpret_cast<QStringList*>(_v) = _t->onFailure(); break;
        case 44: *reinterpret_cast<QString*>(_v) = _t->onFailureJobMode(); break;
        case 45: *reinterpret_cast<QStringList*>(_v) = _t->partOf(); break;
        case 46: *reinterpret_cast<bool*>(_v) = _t->perpetual(); break;
        case 47: *reinterpret_cast<QStringList*>(_v) = _t->propagatesReloadTo(); break;
        case 48: *reinterpret_cast<QString*>(_v) = _t->rebootArgument(); break;
        case 49: *reinterpret_cast<bool*>(_v) = _t->refuseManualStart(); break;
        case 50: *reinterpret_cast<bool*>(_v) = _t->refuseManualStop(); break;
        case 51: *reinterpret_cast<QStringList*>(_v) = _t->reloadPropagatedFrom(); break;
        case 52: *reinterpret_cast<QStringList*>(_v) = _t->requiredBy(); break;
        case 53: *reinterpret_cast<QStringList*>(_v) = _t->requiresMountsFor(); break;
        case 54: *reinterpret_cast<QStringList*>(_v) = _t->requisite(); break;
        case 55: *reinterpret_cast<QStringList*>(_v) = _t->requisiteOf(); break;
        case 56: *reinterpret_cast<QString*>(_v) = _t->sourcePath(); break;
        case 57: *reinterpret_cast<QString*>(_v) = _t->startLimitAction(); break;
        case 58: *reinterpret_cast<uint*>(_v) = _t->startLimitBurst(); break;
        case 59: *reinterpret_cast<qulonglong*>(_v) = _t->startLimitIntervalSec(); break;
        case 60: *reinterpret_cast<qulonglong*>(_v) = _t->stateChangeTimestamp(); break;
        case 61: *reinterpret_cast<qulonglong*>(_v) = _t->stateChangeTimestampMonotonic(); break;
        case 62: *reinterpret_cast<bool*>(_v) = _t->stopWhenUnneeded(); break;
        case 63: *reinterpret_cast<QString*>(_v) = _t->subState(); break;
        case 64: *reinterpret_cast<bool*>(_v) = _t->transient(); break;
        case 65: *reinterpret_cast<QStringList*>(_v) = _t->triggeredBy(); break;
        case 66: *reinterpret_cast<QStringList*>(_v) = _t->triggers(); break;
        case 67: *reinterpret_cast<QString*>(_v) = _t->unitFilePreset(); break;
        case 68: *reinterpret_cast<QString*>(_v) = _t->unitFileState(); break;
        case 69: *reinterpret_cast<QStringList*>(_v) = _t->wantedBy(); break;
        case 70: *reinterpret_cast<QStringList*>(_v) = _t->wants(); break;
        default: break;
        }
    }
}

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

void *OrgFreedesktopSystemd1UnitInterface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN35OrgFreedesktopSystemd1UnitInterfaceE_t>.strings))
        return static_cast<void*>(this);
    return QDBusAbstractInterface::qt_metacast(_clname);
}

int OrgFreedesktopSystemd1UnitInterface::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 < 11)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 11;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 11)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 11;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 71;
    }
    return _id;
}
QT_WARNING_POP
