/****************************************************************************
** Meta object code from reading C++ file 'org_freedesktop_systemd1_Manager.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 "../../../../dbusinterface/org_freedesktop_systemd1_Manager.h"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'org_freedesktop_systemd1_Manager.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_ZN17__Systemd1ManagerE_t {};
} // unnamed namespace

template <> constexpr inline auto __Systemd1Manager::qt_create_metaobjectdata<qt_meta_tag_ZN17__Systemd1ManagerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "__Systemd1Manager",
        "JobNew",
        "",
        "in0",
        "QDBusObjectPath",
        "in1",
        "in2",
        "JobRemoved",
        "in3",
        "Reloading",
        "StartupFinished",
        "in4",
        "in5",
        "UnitFilesChanged",
        "UnitNew",
        "UnitRemoved",
        "ArchitectureChanged",
        "value",
        "ConfirmSpawnChanged",
        "ControlGroupChanged",
        "DefaultBlockIOAccountingChanged",
        "DefaultCPUAccountingChanged",
        "DefaultLimitASChanged",
        "DefaultLimitASSoftChanged",
        "DefaultLimitCOREChanged",
        "DefaultLimitCORESoftChanged",
        "DefaultLimitCPUChanged",
        "DefaultLimitCPUSoftChanged",
        "DefaultLimitDATAChanged",
        "DefaultLimitDATASoftChanged",
        "DefaultLimitFSIZEChanged",
        "DefaultLimitFSIZESoftChanged",
        "DefaultLimitLOCKSChanged",
        "DefaultLimitLOCKSSoftChanged",
        "DefaultLimitMEMLOCKChanged",
        "DefaultLimitMEMLOCKSoftChanged",
        "DefaultLimitMSGQUEUEChanged",
        "DefaultLimitMSGQUEUESoftChanged",
        "DefaultLimitNICEChanged",
        "DefaultLimitNICESoftChanged",
        "DefaultLimitNOFILEChanged",
        "DefaultLimitNOFILESoftChanged",
        "DefaultLimitNPROCChanged",
        "DefaultLimitNPROCSoftChanged",
        "DefaultLimitRSSChanged",
        "DefaultLimitRSSSoftChanged",
        "DefaultLimitRTPRIOChanged",
        "DefaultLimitRTPRIOSoftChanged",
        "DefaultLimitRTTIMEChanged",
        "DefaultLimitRTTIMESoftChanged",
        "DefaultLimitSIGPENDINGChanged",
        "DefaultLimitSIGPENDINGSoftChanged",
        "DefaultLimitSTACKChanged",
        "DefaultLimitSTACKSoftChanged",
        "DefaultMemoryAccountingChanged",
        "DefaultRestartUSecChanged",
        "DefaultStandardErrorChanged",
        "DefaultStandardOutputChanged",
        "DefaultStartLimitBurstChanged",
        "DefaultStartLimitIntervalUSecChanged",
        "DefaultTasksAccountingChanged",
        "DefaultTasksMaxChanged",
        "DefaultTimeoutStartUSecChanged",
        "DefaultTimeoutStopUSecChanged",
        "DefaultTimerAccuracyUSecChanged",
        "EnvironmentChanged",
        "ExitCodeChanged",
        "FeaturesChanged",
        "FinishTimestampChanged",
        "FinishTimestampMonotonicChanged",
        "FirmwareTimestampChanged",
        "FirmwareTimestampMonotonicChanged",
        "GeneratorsFinishTimestampChanged",
        "GeneratorsFinishTimestampMonotonicChanged",
        "GeneratorsStartTimestampChanged",
        "GeneratorsStartTimestampMonotonicChanged",
        "InitRDGeneratorsFinishTimestampChanged",
        "InitRDGeneratorsFinishTimestampMonotonicChanged",
        "InitRDGeneratorsStartTimestampChanged",
        "InitRDGeneratorsStartTimestampMonotonicChanged",
        "InitRDSecurityFinishTimestampChanged",
        "InitRDSecurityFinishTimestampMonotonicChanged",
        "InitRDSecurityStartTimestampChanged",
        "InitRDSecurityStartTimestampMonotonicChanged",
        "InitRDTimestampChanged",
        "InitRDTimestampMonotonicChanged",
        "InitRDUnitsLoadFinishTimestampChanged",
        "InitRDUnitsLoadFinishTimestampMonotonicChanged",
        "InitRDUnitsLoadStartTimestampChanged",
        "InitRDUnitsLoadStartTimestampMonotonicChanged",
        "KernelTimestampChanged",
        "KernelTimestampMonotonicChanged",
        "LoaderTimestampChanged",
        "LoaderTimestampMonotonicChanged",
        "LogLevelChanged",
        "LogTargetChanged",
        "NFailedJobsChanged",
        "NFailedUnitsChanged",
        "NInstalledJobsChanged",
        "NJobsChanged",
        "NNamesChanged",
        "ProgressChanged",
        "RuntimeWatchdogUSecChanged",
        "SecurityFinishTimestampChanged",
        "SecurityFinishTimestampMonotonicChanged",
        "SecurityStartTimestampChanged",
        "SecurityStartTimestampMonotonicChanged",
        "ServiceWatchdogsChanged",
        "ShowStatusChanged",
        "ShutdownWatchdogUSecChanged",
        "SystemStateChanged",
        "TaintedChanged",
        "TimerSlackNSecChanged",
        "UnitPathChanged",
        "UnitsLoadFinishTimestampChanged",
        "UnitsLoadFinishTimestampMonotonicChanged",
        "UnitsLoadStartTimestampChanged",
        "UnitsLoadStartTimestampMonotonicChanged",
        "UserspaceTimestampChanged",
        "UserspaceTimestampMonotonicChanged",
        "VersionChanged",
        "VirtualizationChanged",
        "AbandonScope",
        "QDBusPendingReply<>",
        "AbandonScopeQueued",
        "Dump",
        "QDBusPendingReply<QString>",
        "DumpByFileDescriptor",
        "QDBusPendingReply<QDBusUnixFileDescriptor>",
        "Exit",
        "ExitQueued",
        "GetJob",
        "QDBusPendingReply<QDBusObjectPath>",
        "GetUnit",
        "GetUnitByControlGroup",
        "GetUnitByInvocationID",
        "GetUnitByPID",
        "GetUnitFileLinks",
        "QDBusPendingReply<QStringList>",
        "GetUnitFileState",
        "Halt",
        "HaltQueued",
        "KExec",
        "KExecQueued",
        "KillUnit",
        "KillUnitQueued",
        "LoadUnit",
        "LookupDynamicUserByName",
        "QDBusPendingReply<uint>",
        "LookupDynamicUserByUID",
        "MaskUnitFiles",
        "QDBusPendingReply<StringStructList>",
        "PowerOff",
        "PowerOffQueued",
        "Reboot",
        "RebootQueued",
        "Reexecute",
        "ReexecuteQueued",
        "RefUnit",
        "RefUnitQueued",
        "Reload",
        "ReloadQueued",
        "ReloadOrRestartUnit",
        "ReloadOrTryRestartUnit",
        "ReloadUnit",
        "ResetFailedUnit",
        "ResetFailedUnitQueued",
        "RestartUnit",
        "SetEnvironment",
        "SetEnvironmentQueued",
        "SetExitCode",
        "SetExitCodeQueued",
        "StartUnit",
        "StartUnitReplace",
        "StopUnit",
        "Subscribe",
        "SubscribeQueued",
        "SwitchRoot",
        "SwitchRootQueued",
        "TryRestartUnit",
        "UnmaskUnitFiles",
        "UnrefUnit",
        "UnrefUnitQueued",
        "UnsetAndSetEnvironment",
        "UnsetAndSetEnvironmentQueued",
        "UnsetEnvironment",
        "UnsetEnvironmentQueued",
        "Unsubscribe",
        "UnsubscribeQueued",
        "CallQueued",
        "callName",
        "QList<QVariant>",
        "args",
        "onPendingCallFinished",
        "QDBusPendingCallWatcher*",
        "w",
        "onPropertyChanged",
        "propName",
        "QVariant",
        "Architecture",
        "ConfirmSpawn",
        "ControlGroup",
        "DefaultBlockIOAccounting",
        "DefaultCPUAccounting",
        "DefaultLimitAS",
        "DefaultLimitASSoft",
        "DefaultLimitCORE",
        "DefaultLimitCORESoft",
        "DefaultLimitCPU",
        "DefaultLimitCPUSoft",
        "DefaultLimitDATA",
        "DefaultLimitDATASoft",
        "DefaultLimitFSIZE",
        "DefaultLimitFSIZESoft",
        "DefaultLimitLOCKS",
        "DefaultLimitLOCKSSoft",
        "DefaultLimitMEMLOCK",
        "DefaultLimitMEMLOCKSoft",
        "DefaultLimitMSGQUEUE",
        "DefaultLimitMSGQUEUESoft",
        "DefaultLimitNICE",
        "DefaultLimitNICESoft",
        "DefaultLimitNOFILE",
        "DefaultLimitNOFILESoft",
        "DefaultLimitNPROC",
        "DefaultLimitNPROCSoft",
        "DefaultLimitRSS",
        "DefaultLimitRSSSoft",
        "DefaultLimitRTPRIO",
        "DefaultLimitRTPRIOSoft",
        "DefaultLimitRTTIME",
        "DefaultLimitRTTIMESoft",
        "DefaultLimitSIGPENDING",
        "DefaultLimitSIGPENDINGSoft",
        "DefaultLimitSTACK",
        "DefaultLimitSTACKSoft",
        "DefaultMemoryAccounting",
        "DefaultRestartUSec",
        "DefaultStandardError",
        "DefaultStandardOutput",
        "DefaultStartLimitBurst",
        "DefaultStartLimitIntervalUSec",
        "DefaultTasksAccounting",
        "DefaultTasksMax",
        "DefaultTimeoutStartUSec",
        "DefaultTimeoutStopUSec",
        "DefaultTimerAccuracyUSec",
        "Environment",
        "ExitCode",
        "Features",
        "FinishTimestamp",
        "FinishTimestampMonotonic",
        "FirmwareTimestamp",
        "FirmwareTimestampMonotonic",
        "GeneratorsFinishTimestamp",
        "GeneratorsFinishTimestampMonotonic",
        "GeneratorsStartTimestamp",
        "GeneratorsStartTimestampMonotonic",
        "InitRDGeneratorsFinishTimestamp",
        "InitRDGeneratorsFinishTimestampMonotonic",
        "InitRDGeneratorsStartTimestamp",
        "InitRDGeneratorsStartTimestampMonotonic",
        "InitRDSecurityFinishTimestamp",
        "InitRDSecurityFinishTimestampMonotonic",
        "InitRDSecurityStartTimestamp",
        "InitRDSecurityStartTimestampMonotonic",
        "InitRDTimestamp",
        "InitRDTimestampMonotonic",
        "InitRDUnitsLoadFinishTimestamp",
        "InitRDUnitsLoadFinishTimestampMonotonic",
        "InitRDUnitsLoadStartTimestamp",
        "InitRDUnitsLoadStartTimestampMonotonic",
        "KernelTimestamp",
        "KernelTimestampMonotonic",
        "LoaderTimestamp",
        "LoaderTimestampMonotonic",
        "LogLevel",
        "LogTarget",
        "NFailedJobs",
        "NFailedUnits",
        "NInstalledJobs",
        "NJobs",
        "NNames",
        "Progress",
        "RuntimeWatchdogUSec",
        "SecurityFinishTimestamp",
        "SecurityFinishTimestampMonotonic",
        "SecurityStartTimestamp",
        "SecurityStartTimestampMonotonic",
        "ServiceWatchdogs",
        "ShowStatus",
        "ShutdownWatchdogUSec",
        "SystemState",
        "Tainted",
        "TimerSlackNSec",
        "UnitPath",
        "UnitsLoadFinishTimestamp",
        "UnitsLoadFinishTimestampMonotonic",
        "UnitsLoadStartTimestamp",
        "UnitsLoadStartTimestampMonotonic",
        "UserspaceTimestamp",
        "UserspaceTimestampMonotonic",
        "Version",
        "Virtualization"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'JobNew'
        QtMocHelpers::SignalData<void(uint, const QDBusObjectPath &, const QString &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 3 }, { 0x80000000 | 4, 5 }, { QMetaType::QString, 6 },
        }}),
        // Signal 'JobRemoved'
        QtMocHelpers::SignalData<void(uint, const QDBusObjectPath &, const QString &, const QString &)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 3 }, { 0x80000000 | 4, 5 }, { QMetaType::QString, 6 }, { QMetaType::QString, 8 },
        }}),
        // Signal 'Reloading'
        QtMocHelpers::SignalData<void(bool)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'StartupFinished'
        QtMocHelpers::SignalData<void(qulonglong, qulonglong, qulonglong, qulonglong, qulonglong, qulonglong)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 3 }, { QMetaType::ULongLong, 5 }, { QMetaType::ULongLong, 6 }, { QMetaType::ULongLong, 8 },
            { QMetaType::ULongLong, 11 }, { QMetaType::ULongLong, 12 },
        }}),
        // Signal 'UnitFilesChanged'
        QtMocHelpers::SignalData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'UnitNew'
        QtMocHelpers::SignalData<void(const QString &, const QDBusObjectPath &)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { 0x80000000 | 4, 5 },
        }}),
        // Signal 'UnitRemoved'
        QtMocHelpers::SignalData<void(const QString &, const QDBusObjectPath &)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { 0x80000000 | 4, 5 },
        }}),
        // Signal 'ArchitectureChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Signal 'ConfirmSpawnChanged'
        QtMocHelpers::SignalData<void(bool) const>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'ControlGroupChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Signal 'DefaultBlockIOAccountingChanged'
        QtMocHelpers::SignalData<void(bool) const>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'DefaultCPUAccountingChanged'
        QtMocHelpers::SignalData<void(bool) const>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'DefaultLimitASChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitASSoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitCOREChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitCORESoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitCPUChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitCPUSoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitDATAChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitDATASoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitFSIZEChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitFSIZESoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitLOCKSChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitLOCKSSoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitMEMLOCKChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitMEMLOCKSoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitMSGQUEUEChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitMSGQUEUESoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitNICEChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitNICESoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitNOFILEChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitNOFILESoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitNPROCChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitNPROCSoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitRSSChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitRSSSoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitRTPRIOChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitRTPRIOSoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitRTTIMEChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitRTTIMESoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitSIGPENDINGChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitSIGPENDINGSoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitSTACKChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultLimitSTACKSoftChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultMemoryAccountingChanged'
        QtMocHelpers::SignalData<void(bool) const>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'DefaultRestartUSecChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultStandardErrorChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Signal 'DefaultStandardOutputChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Signal 'DefaultStartLimitBurstChanged'
        QtMocHelpers::SignalData<void(uint) const>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 17 },
        }}),
        // Signal 'DefaultStartLimitIntervalUSecChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultTasksAccountingChanged'
        QtMocHelpers::SignalData<void(bool) const>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'DefaultTasksMaxChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultTimeoutStartUSecChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultTimeoutStopUSecChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'DefaultTimerAccuracyUSecChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'EnvironmentChanged'
        QtMocHelpers::SignalData<void(const QStringList &) const>(65, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 17 },
        }}),
        // Signal 'ExitCodeChanged'
        QtMocHelpers::SignalData<void(uchar) const>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UChar, 17 },
        }}),
        // Signal 'FeaturesChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Signal 'FinishTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'FinishTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'FirmwareTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'FirmwareTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(71, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'GeneratorsFinishTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'GeneratorsFinishTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'GeneratorsStartTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(74, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'GeneratorsStartTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(75, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDGeneratorsFinishTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(76, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDGeneratorsFinishTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDGeneratorsStartTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(78, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDGeneratorsStartTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDSecurityFinishTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(80, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDSecurityFinishTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(81, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDSecurityStartTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(82, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDSecurityStartTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(83, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDUnitsLoadFinishTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(86, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDUnitsLoadFinishTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(87, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDUnitsLoadStartTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'InitRDUnitsLoadStartTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(89, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'KernelTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(90, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'KernelTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'LoaderTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(92, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'LoaderTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(93, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'LogLevelChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Signal 'LogTargetChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(95, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Signal 'NFailedJobsChanged'
        QtMocHelpers::SignalData<void(uint) const>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 17 },
        }}),
        // Signal 'NFailedUnitsChanged'
        QtMocHelpers::SignalData<void(uint) const>(97, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 17 },
        }}),
        // Signal 'NInstalledJobsChanged'
        QtMocHelpers::SignalData<void(uint) const>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 17 },
        }}),
        // Signal 'NJobsChanged'
        QtMocHelpers::SignalData<void(uint) const>(99, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 17 },
        }}),
        // Signal 'NNamesChanged'
        QtMocHelpers::SignalData<void(uint) const>(100, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 17 },
        }}),
        // Signal 'ProgressChanged'
        QtMocHelpers::SignalData<void(double) const>(101, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Double, 17 },
        }}),
        // Signal 'RuntimeWatchdogUSecChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(102, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'SecurityFinishTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(103, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'SecurityFinishTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(104, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'SecurityStartTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'SecurityStartTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(106, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'ServiceWatchdogsChanged'
        QtMocHelpers::SignalData<void(bool) const>(107, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'ShowStatusChanged'
        QtMocHelpers::SignalData<void(bool) const>(108, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'ShutdownWatchdogUSecChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(109, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'SystemStateChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(110, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Signal 'TaintedChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(111, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Signal 'TimerSlackNSecChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(112, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'UnitPathChanged'
        QtMocHelpers::SignalData<void(const QStringList &) const>(113, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 17 },
        }}),
        // Signal 'UnitsLoadFinishTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(114, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'UnitsLoadFinishTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(115, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'UnitsLoadStartTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(116, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'UnitsLoadStartTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(117, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'UserspaceTimestampChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(118, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'UserspaceTimestampMonotonicChanged'
        QtMocHelpers::SignalData<void(qulonglong) const>(119, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 17 },
        }}),
        // Signal 'VersionChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(120, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Signal 'VirtualizationChanged'
        QtMocHelpers::SignalData<void(const QString &) const>(121, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Slot 'AbandonScope'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(122, 2, QMC::AccessPublic, 0x80000000 | 123, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'AbandonScopeQueued'
        QtMocHelpers::SlotData<void(const QString &)>(124, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'Dump'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(125, 2, QMC::AccessPublic, 0x80000000 | 126),
        // Slot 'DumpByFileDescriptor'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusUnixFileDescriptor>()>(127, 2, QMC::AccessPublic, 0x80000000 | 128),
        // Slot 'Exit'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(129, 2, QMC::AccessPublic, 0x80000000 | 123),
        // Slot 'ExitQueued'
        QtMocHelpers::SlotData<void()>(130, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'GetJob'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(uint)>(131, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::UInt, 3 },
        }}),
        // Slot 'GetUnit'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &)>(133, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'GetUnitByControlGroup'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &)>(134, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'GetUnitByInvocationID'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QByteArray &)>(135, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QByteArray, 3 },
        }}),
        // Slot 'GetUnitByPID'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(uint)>(136, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::UInt, 3 },
        }}),
        // Slot 'GetUnitFileLinks'
        QtMocHelpers::SlotData<QDBusPendingReply<QStringList>(const QString &, bool)>(137, 2, QMC::AccessPublic, 0x80000000 | 138, {{
            { QMetaType::QString, 3 }, { QMetaType::Bool, 5 },
        }}),
        // Slot 'GetUnitFileState'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>(const QString &)>(139, 2, QMC::AccessPublic, 0x80000000 | 126, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'Halt'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(140, 2, QMC::AccessPublic, 0x80000000 | 123),
        // Slot 'HaltQueued'
        QtMocHelpers::SlotData<void()>(141, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'KExec'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(142, 2, QMC::AccessPublic, 0x80000000 | 123),
        // Slot 'KExecQueued'
        QtMocHelpers::SlotData<void()>(143, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'KillUnit'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &, const QString &, int)>(144, 2, QMC::AccessPublic, 0x80000000 | 123, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 5 }, { QMetaType::Int, 6 },
        }}),
        // Slot 'KillUnitQueued'
        QtMocHelpers::SlotData<void(const QString &, const QString &, int)>(145, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 5 }, { QMetaType::Int, 6 },
        }}),
        // Slot 'LoadUnit'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &)>(146, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'LookupDynamicUserByName'
        QtMocHelpers::SlotData<QDBusPendingReply<uint>(const QString &)>(147, 2, QMC::AccessPublic, 0x80000000 | 148, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'LookupDynamicUserByUID'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>(uint)>(149, 2, QMC::AccessPublic, 0x80000000 | 126, {{
            { QMetaType::UInt, 3 },
        }}),
        // Slot 'MaskUnitFiles'
        QtMocHelpers::SlotData<QDBusPendingReply<StringStructList>(const QStringList &, bool, bool)>(150, 2, QMC::AccessPublic, 0x80000000 | 151, {{
            { QMetaType::QStringList, 3 }, { QMetaType::Bool, 5 }, { QMetaType::Bool, 6 },
        }}),
        // Slot 'PowerOff'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(152, 2, QMC::AccessPublic, 0x80000000 | 123),
        // Slot 'PowerOffQueued'
        QtMocHelpers::SlotData<void()>(153, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'Reboot'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(154, 2, QMC::AccessPublic, 0x80000000 | 123),
        // Slot 'RebootQueued'
        QtMocHelpers::SlotData<void()>(155, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'Reexecute'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(156, 2, QMC::AccessPublic, 0x80000000 | 123),
        // Slot 'ReexecuteQueued'
        QtMocHelpers::SlotData<void()>(157, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'RefUnit'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(158, 2, QMC::AccessPublic, 0x80000000 | 123, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'RefUnitQueued'
        QtMocHelpers::SlotData<void(const QString &)>(159, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'Reload'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(160, 2, QMC::AccessPublic, 0x80000000 | 123),
        // Slot 'ReloadQueued'
        QtMocHelpers::SlotData<void()>(161, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'ReloadOrRestartUnit'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &, const QString &)>(162, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 5 },
        }}),
        // Slot 'ReloadOrTryRestartUnit'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &, const QString &)>(163, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 5 },
        }}),
        // Slot 'ReloadUnit'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &, const QString &)>(164, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 5 },
        }}),
        // Slot 'ResetFailedUnit'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(165, 2, QMC::AccessPublic, 0x80000000 | 123, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'ResetFailedUnitQueued'
        QtMocHelpers::SlotData<void(const QString &)>(166, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'RestartUnit'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &, const QString &)>(167, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 5 },
        }}),
        // Slot 'SetEnvironment'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QStringList &)>(168, 2, QMC::AccessPublic, 0x80000000 | 123, {{
            { QMetaType::QStringList, 3 },
        }}),
        // Slot 'SetEnvironmentQueued'
        QtMocHelpers::SlotData<void(const QStringList &)>(169, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 3 },
        }}),
        // Slot 'SetExitCode'
        QtMocHelpers::SlotData<QDBusPendingReply<>(uchar)>(170, 2, QMC::AccessPublic, 0x80000000 | 123, {{
            { QMetaType::UChar, 3 },
        }}),
        // Slot 'SetExitCodeQueued'
        QtMocHelpers::SlotData<void(uchar)>(171, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UChar, 3 },
        }}),
        // Slot 'StartUnit'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &, const QString &)>(172, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 5 },
        }}),
        // Slot 'StartUnitReplace'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &, const QString &, const QString &)>(173, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 5 }, { QMetaType::QString, 6 },
        }}),
        // Slot 'StopUnit'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &, const QString &)>(174, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 5 },
        }}),
        // Slot 'Subscribe'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(175, 2, QMC::AccessPublic, 0x80000000 | 123),
        // Slot 'SubscribeQueued'
        QtMocHelpers::SlotData<void()>(176, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'SwitchRoot'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &, const QString &)>(177, 2, QMC::AccessPublic, 0x80000000 | 123, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 5 },
        }}),
        // Slot 'SwitchRootQueued'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(178, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 5 },
        }}),
        // Slot 'TryRestartUnit'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &, const QString &)>(179, 2, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QString, 3 }, { QMetaType::QString, 5 },
        }}),
        // Slot 'UnmaskUnitFiles'
        QtMocHelpers::SlotData<QDBusPendingReply<StringStructList>(const QStringList &, bool)>(180, 2, QMC::AccessPublic, 0x80000000 | 151, {{
            { QMetaType::QStringList, 3 }, { QMetaType::Bool, 5 },
        }}),
        // Slot 'UnrefUnit'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(181, 2, QMC::AccessPublic, 0x80000000 | 123, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'UnrefUnitQueued'
        QtMocHelpers::SlotData<void(const QString &)>(182, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'UnsetAndSetEnvironment'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QStringList &, const QStringList &)>(183, 2, QMC::AccessPublic, 0x80000000 | 123, {{
            { QMetaType::QStringList, 3 }, { QMetaType::QStringList, 5 },
        }}),
        // Slot 'UnsetAndSetEnvironmentQueued'
        QtMocHelpers::SlotData<void(const QStringList &, const QStringList &)>(184, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 3 }, { QMetaType::QStringList, 5 },
        }}),
        // Slot 'UnsetEnvironment'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QStringList &)>(185, 2, QMC::AccessPublic, 0x80000000 | 123, {{
            { QMetaType::QStringList, 3 },
        }}),
        // Slot 'UnsetEnvironmentQueued'
        QtMocHelpers::SlotData<void(const QStringList &)>(186, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 3 },
        }}),
        // Slot 'Unsubscribe'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(187, 2, QMC::AccessPublic, 0x80000000 | 123),
        // Slot 'UnsubscribeQueued'
        QtMocHelpers::SlotData<void()>(188, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'CallQueued'
        QtMocHelpers::SlotData<void(const QString &, const QList<QVariant> &)>(189, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 190 }, { 0x80000000 | 191, 192 },
        }}),
        // Slot 'onPendingCallFinished'
        QtMocHelpers::SlotData<void(QDBusPendingCallWatcher *)>(193, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 194, 195 },
        }}),
        // Slot 'onPropertyChanged'
        QtMocHelpers::SlotData<void(const QString &, const QVariant &)>(196, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 197 }, { 0x80000000 | 198, 17 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'Architecture'
        QtMocHelpers::PropertyData<QString>(199, QMetaType::QString, QMC::DefaultPropertyFlags, 7),
        // property 'ConfirmSpawn'
        QtMocHelpers::PropertyData<bool>(200, QMetaType::Bool, QMC::DefaultPropertyFlags, 8),
        // property 'ControlGroup'
        QtMocHelpers::PropertyData<QString>(201, QMetaType::QString, QMC::DefaultPropertyFlags, 9),
        // property 'DefaultBlockIOAccounting'
        QtMocHelpers::PropertyData<bool>(202, QMetaType::Bool, QMC::DefaultPropertyFlags, 10),
        // property 'DefaultCPUAccounting'
        QtMocHelpers::PropertyData<bool>(203, QMetaType::Bool, QMC::DefaultPropertyFlags, 11),
        // property 'DefaultLimitAS'
        QtMocHelpers::PropertyData<qulonglong>(204, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 12),
        // property 'DefaultLimitASSoft'
        QtMocHelpers::PropertyData<qulonglong>(205, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 13),
        // property 'DefaultLimitCORE'
        QtMocHelpers::PropertyData<qulonglong>(206, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 14),
        // property 'DefaultLimitCORESoft'
        QtMocHelpers::PropertyData<qulonglong>(207, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 15),
        // property 'DefaultLimitCPU'
        QtMocHelpers::PropertyData<qulonglong>(208, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 16),
        // property 'DefaultLimitCPUSoft'
        QtMocHelpers::PropertyData<qulonglong>(209, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 17),
        // property 'DefaultLimitDATA'
        QtMocHelpers::PropertyData<qulonglong>(210, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 18),
        // property 'DefaultLimitDATASoft'
        QtMocHelpers::PropertyData<qulonglong>(211, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 19),
        // property 'DefaultLimitFSIZE'
        QtMocHelpers::PropertyData<qulonglong>(212, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 20),
        // property 'DefaultLimitFSIZESoft'
        QtMocHelpers::PropertyData<qulonglong>(213, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 21),
        // property 'DefaultLimitLOCKS'
        QtMocHelpers::PropertyData<qulonglong>(214, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 22),
        // property 'DefaultLimitLOCKSSoft'
        QtMocHelpers::PropertyData<qulonglong>(215, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 23),
        // property 'DefaultLimitMEMLOCK'
        QtMocHelpers::PropertyData<qulonglong>(216, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 24),
        // property 'DefaultLimitMEMLOCKSoft'
        QtMocHelpers::PropertyData<qulonglong>(217, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 25),
        // property 'DefaultLimitMSGQUEUE'
        QtMocHelpers::PropertyData<qulonglong>(218, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 26),
        // property 'DefaultLimitMSGQUEUESoft'
        QtMocHelpers::PropertyData<qulonglong>(219, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 27),
        // property 'DefaultLimitNICE'
        QtMocHelpers::PropertyData<qulonglong>(220, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 28),
        // property 'DefaultLimitNICESoft'
        QtMocHelpers::PropertyData<qulonglong>(221, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 29),
        // property 'DefaultLimitNOFILE'
        QtMocHelpers::PropertyData<qulonglong>(222, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 30),
        // property 'DefaultLimitNOFILESoft'
        QtMocHelpers::PropertyData<qulonglong>(223, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 31),
        // property 'DefaultLimitNPROC'
        QtMocHelpers::PropertyData<qulonglong>(224, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 32),
        // property 'DefaultLimitNPROCSoft'
        QtMocHelpers::PropertyData<qulonglong>(225, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 33),
        // property 'DefaultLimitRSS'
        QtMocHelpers::PropertyData<qulonglong>(226, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 34),
        // property 'DefaultLimitRSSSoft'
        QtMocHelpers::PropertyData<qulonglong>(227, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 35),
        // property 'DefaultLimitRTPRIO'
        QtMocHelpers::PropertyData<qulonglong>(228, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 36),
        // property 'DefaultLimitRTPRIOSoft'
        QtMocHelpers::PropertyData<qulonglong>(229, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 37),
        // property 'DefaultLimitRTTIME'
        QtMocHelpers::PropertyData<qulonglong>(230, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 38),
        // property 'DefaultLimitRTTIMESoft'
        QtMocHelpers::PropertyData<qulonglong>(231, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 39),
        // property 'DefaultLimitSIGPENDING'
        QtMocHelpers::PropertyData<qulonglong>(232, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 40),
        // property 'DefaultLimitSIGPENDINGSoft'
        QtMocHelpers::PropertyData<qulonglong>(233, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 41),
        // property 'DefaultLimitSTACK'
        QtMocHelpers::PropertyData<qulonglong>(234, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 42),
        // property 'DefaultLimitSTACKSoft'
        QtMocHelpers::PropertyData<qulonglong>(235, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 43),
        // property 'DefaultMemoryAccounting'
        QtMocHelpers::PropertyData<bool>(236, QMetaType::Bool, QMC::DefaultPropertyFlags, 44),
        // property 'DefaultRestartUSec'
        QtMocHelpers::PropertyData<qulonglong>(237, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 45),
        // property 'DefaultStandardError'
        QtMocHelpers::PropertyData<QString>(238, QMetaType::QString, QMC::DefaultPropertyFlags, 46),
        // property 'DefaultStandardOutput'
        QtMocHelpers::PropertyData<QString>(239, QMetaType::QString, QMC::DefaultPropertyFlags, 47),
        // property 'DefaultStartLimitBurst'
        QtMocHelpers::PropertyData<uint>(240, QMetaType::UInt, QMC::DefaultPropertyFlags, 48),
        // property 'DefaultStartLimitIntervalUSec'
        QtMocHelpers::PropertyData<qulonglong>(241, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 49),
        // property 'DefaultTasksAccounting'
        QtMocHelpers::PropertyData<bool>(242, QMetaType::Bool, QMC::DefaultPropertyFlags, 50),
        // property 'DefaultTasksMax'
        QtMocHelpers::PropertyData<qulonglong>(243, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 51),
        // property 'DefaultTimeoutStartUSec'
        QtMocHelpers::PropertyData<qulonglong>(244, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 52),
        // property 'DefaultTimeoutStopUSec'
        QtMocHelpers::PropertyData<qulonglong>(245, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 53),
        // property 'DefaultTimerAccuracyUSec'
        QtMocHelpers::PropertyData<qulonglong>(246, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 54),
        // property 'Environment'
        QtMocHelpers::PropertyData<QStringList>(247, QMetaType::QStringList, QMC::DefaultPropertyFlags, 55),
        // property 'ExitCode'
        QtMocHelpers::PropertyData<uchar>(248, QMetaType::UChar, QMC::DefaultPropertyFlags, 56),
        // property 'Features'
        QtMocHelpers::PropertyData<QString>(249, QMetaType::QString, QMC::DefaultPropertyFlags, 57),
        // property 'FinishTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(250, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 58),
        // property 'FinishTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(251, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 59),
        // property 'FirmwareTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(252, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 60),
        // property 'FirmwareTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(253, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 61),
        // property 'GeneratorsFinishTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(254, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 62),
        // property 'GeneratorsFinishTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(255, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 63),
        // property 'GeneratorsStartTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(256, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 64),
        // property 'GeneratorsStartTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(257, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 65),
        // property 'InitRDGeneratorsFinishTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(258, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 66),
        // property 'InitRDGeneratorsFinishTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(259, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 67),
        // property 'InitRDGeneratorsStartTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(260, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 68),
        // property 'InitRDGeneratorsStartTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(261, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 69),
        // property 'InitRDSecurityFinishTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(262, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 70),
        // property 'InitRDSecurityFinishTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(263, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 71),
        // property 'InitRDSecurityStartTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(264, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 72),
        // property 'InitRDSecurityStartTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(265, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 73),
        // property 'InitRDTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(266, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 74),
        // property 'InitRDTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(267, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 75),
        // property 'InitRDUnitsLoadFinishTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(268, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 76),
        // property 'InitRDUnitsLoadFinishTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(269, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 77),
        // property 'InitRDUnitsLoadStartTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(270, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 78),
        // property 'InitRDUnitsLoadStartTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(271, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 79),
        // property 'KernelTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(272, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 80),
        // property 'KernelTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(273, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 81),
        // property 'LoaderTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(274, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 82),
        // property 'LoaderTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(275, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 83),
        // property 'LogLevel'
        QtMocHelpers::PropertyData<QString>(276, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 84),
        // property 'LogTarget'
        QtMocHelpers::PropertyData<QString>(277, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 85),
        // property 'NFailedJobs'
        QtMocHelpers::PropertyData<uint>(278, QMetaType::UInt, QMC::DefaultPropertyFlags, 86),
        // property 'NFailedUnits'
        QtMocHelpers::PropertyData<uint>(279, QMetaType::UInt, QMC::DefaultPropertyFlags, 87),
        // property 'NInstalledJobs'
        QtMocHelpers::PropertyData<uint>(280, QMetaType::UInt, QMC::DefaultPropertyFlags, 88),
        // property 'NJobs'
        QtMocHelpers::PropertyData<uint>(281, QMetaType::UInt, QMC::DefaultPropertyFlags, 89),
        // property 'NNames'
        QtMocHelpers::PropertyData<uint>(282, QMetaType::UInt, QMC::DefaultPropertyFlags, 90),
        // property 'Progress'
        QtMocHelpers::PropertyData<double>(283, QMetaType::Double, QMC::DefaultPropertyFlags, 91),
        // property 'RuntimeWatchdogUSec'
        QtMocHelpers::PropertyData<qulonglong>(284, QMetaType::ULongLong, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 92),
        // property 'SecurityFinishTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(285, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 93),
        // property 'SecurityFinishTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(286, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 94),
        // property 'SecurityStartTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(287, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 95),
        // property 'SecurityStartTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(288, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 96),
        // property 'ServiceWatchdogs'
        QtMocHelpers::PropertyData<bool>(289, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 97),
        // property 'ShowStatus'
        QtMocHelpers::PropertyData<bool>(290, QMetaType::Bool, QMC::DefaultPropertyFlags, 98),
        // property 'ShutdownWatchdogUSec'
        QtMocHelpers::PropertyData<qulonglong>(291, QMetaType::ULongLong, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 99),
        // property 'SystemState'
        QtMocHelpers::PropertyData<QString>(292, QMetaType::QString, QMC::DefaultPropertyFlags, 100),
        // property 'Tainted'
        QtMocHelpers::PropertyData<QString>(293, QMetaType::QString, QMC::DefaultPropertyFlags, 101),
        // property 'TimerSlackNSec'
        QtMocHelpers::PropertyData<qulonglong>(294, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 102),
        // property 'UnitPath'
        QtMocHelpers::PropertyData<QStringList>(295, QMetaType::QStringList, QMC::DefaultPropertyFlags, 103),
        // property 'UnitsLoadFinishTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(296, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 104),
        // property 'UnitsLoadFinishTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(297, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 105),
        // property 'UnitsLoadStartTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(298, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 106),
        // property 'UnitsLoadStartTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(299, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 107),
        // property 'UserspaceTimestamp'
        QtMocHelpers::PropertyData<qulonglong>(300, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 108),
        // property 'UserspaceTimestampMonotonic'
        QtMocHelpers::PropertyData<qulonglong>(301, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 109),
        // property 'Version'
        QtMocHelpers::PropertyData<QString>(302, QMetaType::QString, QMC::DefaultPropertyFlags, 110),
        // property 'Virtualization'
        QtMocHelpers::PropertyData<QString>(303, QMetaType::QString, QMC::DefaultPropertyFlags, 111),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<__Systemd1Manager, qt_meta_tag_ZN17__Systemd1ManagerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject __Systemd1Manager::staticMetaObject = { {
    QMetaObject::SuperData::link<Dtk::Core::DDBusExtendedAbstractInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17__Systemd1ManagerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17__Systemd1ManagerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17__Systemd1ManagerE_t>.metaTypes,
    nullptr
} };

void __Systemd1Manager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<__Systemd1Manager *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->JobNew((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 1: _t->JobRemoved((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4]))); break;
        case 2: _t->Reloading((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: _t->StartupFinished((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[6]))); break;
        case 4: _t->UnitFilesChanged(); break;
        case 5: _t->UnitNew((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[2]))); break;
        case 6: _t->UnitRemoved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[2]))); break;
        case 7: _t->ArchitectureChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 8: _t->ConfirmSpawnChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->ControlGroupChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 10: _t->DefaultBlockIOAccountingChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 11: _t->DefaultCPUAccountingChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 12: _t->DefaultLimitASChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 13: _t->DefaultLimitASSoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 14: _t->DefaultLimitCOREChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 15: _t->DefaultLimitCORESoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 16: _t->DefaultLimitCPUChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 17: _t->DefaultLimitCPUSoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 18: _t->DefaultLimitDATAChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 19: _t->DefaultLimitDATASoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 20: _t->DefaultLimitFSIZEChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 21: _t->DefaultLimitFSIZESoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 22: _t->DefaultLimitLOCKSChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 23: _t->DefaultLimitLOCKSSoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 24: _t->DefaultLimitMEMLOCKChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 25: _t->DefaultLimitMEMLOCKSoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 26: _t->DefaultLimitMSGQUEUEChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 27: _t->DefaultLimitMSGQUEUESoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 28: _t->DefaultLimitNICEChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 29: _t->DefaultLimitNICESoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 30: _t->DefaultLimitNOFILEChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 31: _t->DefaultLimitNOFILESoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 32: _t->DefaultLimitNPROCChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 33: _t->DefaultLimitNPROCSoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 34: _t->DefaultLimitRSSChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 35: _t->DefaultLimitRSSSoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 36: _t->DefaultLimitRTPRIOChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 37: _t->DefaultLimitRTPRIOSoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 38: _t->DefaultLimitRTTIMEChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 39: _t->DefaultLimitRTTIMESoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 40: _t->DefaultLimitSIGPENDINGChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 41: _t->DefaultLimitSIGPENDINGSoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 42: _t->DefaultLimitSTACKChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 43: _t->DefaultLimitSTACKSoftChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 44: _t->DefaultMemoryAccountingChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 45: _t->DefaultRestartUSecChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 46: _t->DefaultStandardErrorChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 47: _t->DefaultStandardOutputChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 48: _t->DefaultStartLimitBurstChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 49: _t->DefaultStartLimitIntervalUSecChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 50: _t->DefaultTasksAccountingChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 51: _t->DefaultTasksMaxChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 52: _t->DefaultTimeoutStartUSecChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 53: _t->DefaultTimeoutStopUSecChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 54: _t->DefaultTimerAccuracyUSecChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 55: _t->EnvironmentChanged((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 56: _t->ExitCodeChanged((*reinterpret_cast<std::add_pointer_t<uchar>>(_a[1]))); break;
        case 57: _t->FeaturesChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 58: _t->FinishTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 59: _t->FinishTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 60: _t->FirmwareTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 61: _t->FirmwareTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 62: _t->GeneratorsFinishTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 63: _t->GeneratorsFinishTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 64: _t->GeneratorsStartTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 65: _t->GeneratorsStartTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 66: _t->InitRDGeneratorsFinishTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 67: _t->InitRDGeneratorsFinishTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 68: _t->InitRDGeneratorsStartTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 69: _t->InitRDGeneratorsStartTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 70: _t->InitRDSecurityFinishTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 71: _t->InitRDSecurityFinishTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 72: _t->InitRDSecurityStartTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 73: _t->InitRDSecurityStartTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 74: _t->InitRDTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 75: _t->InitRDTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 76: _t->InitRDUnitsLoadFinishTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 77: _t->InitRDUnitsLoadFinishTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 78: _t->InitRDUnitsLoadStartTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 79: _t->InitRDUnitsLoadStartTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 80: _t->KernelTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 81: _t->KernelTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 82: _t->LoaderTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 83: _t->LoaderTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 84: _t->LogLevelChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 85: _t->LogTargetChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 86: _t->NFailedJobsChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 87: _t->NFailedUnitsChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 88: _t->NInstalledJobsChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 89: _t->NJobsChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 90: _t->NNamesChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 91: _t->ProgressChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 92: _t->RuntimeWatchdogUSecChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 93: _t->SecurityFinishTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 94: _t->SecurityFinishTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 95: _t->SecurityStartTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 96: _t->SecurityStartTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 97: _t->ServiceWatchdogsChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 98: _t->ShowStatusChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 99: _t->ShutdownWatchdogUSecChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 100: _t->SystemStateChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 101: _t->TaintedChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 102: _t->TimerSlackNSecChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 103: _t->UnitPathChanged((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 104: _t->UnitsLoadFinishTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 105: _t->UnitsLoadFinishTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 106: _t->UnitsLoadStartTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 107: _t->UnitsLoadStartTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 108: _t->UserspaceTimestampChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 109: _t->UserspaceTimestampMonotonicChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 110: _t->VersionChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 111: _t->VirtualizationChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 112: { QDBusPendingReply<> _r = _t->AbandonScope((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 113: _t->AbandonScopeQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 114: { QDBusPendingReply<QString> _r = _t->Dump();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 115: { QDBusPendingReply<QDBusUnixFileDescriptor> _r = _t->DumpByFileDescriptor();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusUnixFileDescriptor>*>(_a[0]) = std::move(_r); }  break;
        case 116: { QDBusPendingReply<> _r = _t->Exit();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 117: _t->ExitQueued(); break;
        case 118: { QDBusPendingReply<QDBusObjectPath> _r = _t->GetJob((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 119: { QDBusPendingReply<QDBusObjectPath> _r = _t->GetUnit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 120: { QDBusPendingReply<QDBusObjectPath> _r = _t->GetUnitByControlGroup((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 121: { QDBusPendingReply<QDBusObjectPath> _r = _t->GetUnitByInvocationID((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 122: { QDBusPendingReply<QDBusObjectPath> _r = _t->GetUnitByPID((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 123: { QDBusPendingReply<QStringList> _r = _t->GetUnitFileLinks((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QStringList>*>(_a[0]) = std::move(_r); }  break;
        case 124: { QDBusPendingReply<QString> _r = _t->GetUnitFileState((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 125: { QDBusPendingReply<> _r = _t->Halt();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 126: _t->HaltQueued(); break;
        case 127: { QDBusPendingReply<> _r = _t->KExec();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 128: _t->KExecQueued(); break;
        case 129: { QDBusPendingReply<> _r = _t->KillUnit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 130: _t->KillUnitQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 131: { QDBusPendingReply<QDBusObjectPath> _r = _t->LoadUnit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 132: { QDBusPendingReply<uint> _r = _t->LookupDynamicUserByName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<uint>*>(_a[0]) = std::move(_r); }  break;
        case 133: { QDBusPendingReply<QString> _r = _t->LookupDynamicUserByUID((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 134: { QDBusPendingReply<StringStructList> _r = _t->MaskUnitFiles((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<StringStructList>*>(_a[0]) = std::move(_r); }  break;
        case 135: { QDBusPendingReply<> _r = _t->PowerOff();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 136: _t->PowerOffQueued(); break;
        case 137: { QDBusPendingReply<> _r = _t->Reboot();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 138: _t->RebootQueued(); break;
        case 139: { QDBusPendingReply<> _r = _t->Reexecute();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 140: _t->ReexecuteQueued(); break;
        case 141: { QDBusPendingReply<> _r = _t->RefUnit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 142: _t->RefUnitQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 143: { QDBusPendingReply<> _r = _t->Reload();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 144: _t->ReloadQueued(); break;
        case 145: { QDBusPendingReply<QDBusObjectPath> _r = _t->ReloadOrRestartUnit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 146: { QDBusPendingReply<QDBusObjectPath> _r = _t->ReloadOrTryRestartUnit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 147: { QDBusPendingReply<QDBusObjectPath> _r = _t->ReloadUnit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 148: { QDBusPendingReply<> _r = _t->ResetFailedUnit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 149: _t->ResetFailedUnitQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 150: { QDBusPendingReply<QDBusObjectPath> _r = _t->RestartUnit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 151: { QDBusPendingReply<> _r = _t->SetEnvironment((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 152: _t->SetEnvironmentQueued((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 153: { QDBusPendingReply<> _r = _t->SetExitCode((*reinterpret_cast<std::add_pointer_t<uchar>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 154: _t->SetExitCodeQueued((*reinterpret_cast<std::add_pointer_t<uchar>>(_a[1]))); break;
        case 155: { QDBusPendingReply<QDBusObjectPath> _r = _t->StartUnit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 156: { QDBusPendingReply<QDBusObjectPath> _r = _t->StartUnitReplace((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 157: { QDBusPendingReply<QDBusObjectPath> _r = _t->StopUnit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 158: { QDBusPendingReply<> _r = _t->Subscribe();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 159: _t->SubscribeQueued(); break;
        case 160: { QDBusPendingReply<> _r = _t->SwitchRoot((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 161: _t->SwitchRootQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 162: { QDBusPendingReply<QDBusObjectPath> _r = _t->TryRestartUnit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 163: { QDBusPendingReply<StringStructList> _r = _t->UnmaskUnitFiles((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<StringStructList>*>(_a[0]) = std::move(_r); }  break;
        case 164: { QDBusPendingReply<> _r = _t->UnrefUnit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 165: _t->UnrefUnitQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 166: { QDBusPendingReply<> _r = _t->UnsetAndSetEnvironment((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 167: _t->UnsetAndSetEnvironmentQueued((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2]))); break;
        case 168: { QDBusPendingReply<> _r = _t->UnsetEnvironment((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 169: _t->UnsetEnvironmentQueued((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 170: { QDBusPendingReply<> _r = _t->Unsubscribe();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 171: _t->UnsubscribeQueued(); break;
        case 172: _t->CallQueued((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<QVariant>>>(_a[2]))); break;
        case 173: _t->onPendingCallFinished((*reinterpret_cast<std::add_pointer_t<QDBusPendingCallWatcher*>>(_a[1]))); break;
        case 174: _t->onPropertyChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        case 1:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        case 173:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusPendingCallWatcher* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(uint , const QDBusObjectPath & , const QString & )>(_a, &__Systemd1Manager::JobNew, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(uint , const QDBusObjectPath & , const QString & , const QString & )>(_a, &__Systemd1Manager::JobRemoved, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(bool )>(_a, &__Systemd1Manager::Reloading, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong , qulonglong , qulonglong , qulonglong , qulonglong , qulonglong )>(_a, &__Systemd1Manager::StartupFinished, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)()>(_a, &__Systemd1Manager::UnitFilesChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QString & , const QDBusObjectPath & )>(_a, &__Systemd1Manager::UnitNew, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QString & , const QDBusObjectPath & )>(_a, &__Systemd1Manager::UnitRemoved, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QString & ) const>(_a, &__Systemd1Manager::ArchitectureChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(bool ) const>(_a, &__Systemd1Manager::ConfirmSpawnChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QString & ) const>(_a, &__Systemd1Manager::ControlGroupChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(bool ) const>(_a, &__Systemd1Manager::DefaultBlockIOAccountingChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(bool ) const>(_a, &__Systemd1Manager::DefaultCPUAccountingChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitASChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitASSoftChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitCOREChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitCORESoftChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitCPUChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitCPUSoftChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitDATAChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitDATASoftChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitFSIZEChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitFSIZESoftChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitLOCKSChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitLOCKSSoftChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitMEMLOCKChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitMEMLOCKSoftChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitMSGQUEUEChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitMSGQUEUESoftChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitNICEChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitNICESoftChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitNOFILEChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitNOFILESoftChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitNPROCChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitNPROCSoftChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitRSSChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitRSSSoftChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitRTPRIOChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitRTPRIOSoftChanged, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitRTTIMEChanged, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitRTTIMESoftChanged, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitSIGPENDINGChanged, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitSIGPENDINGSoftChanged, 41))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitSTACKChanged, 42))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultLimitSTACKSoftChanged, 43))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(bool ) const>(_a, &__Systemd1Manager::DefaultMemoryAccountingChanged, 44))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultRestartUSecChanged, 45))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QString & ) const>(_a, &__Systemd1Manager::DefaultStandardErrorChanged, 46))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QString & ) const>(_a, &__Systemd1Manager::DefaultStandardOutputChanged, 47))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(uint ) const>(_a, &__Systemd1Manager::DefaultStartLimitBurstChanged, 48))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultStartLimitIntervalUSecChanged, 49))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(bool ) const>(_a, &__Systemd1Manager::DefaultTasksAccountingChanged, 50))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultTasksMaxChanged, 51))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultTimeoutStartUSecChanged, 52))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultTimeoutStopUSecChanged, 53))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::DefaultTimerAccuracyUSecChanged, 54))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QStringList & ) const>(_a, &__Systemd1Manager::EnvironmentChanged, 55))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(uchar ) const>(_a, &__Systemd1Manager::ExitCodeChanged, 56))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QString & ) const>(_a, &__Systemd1Manager::FeaturesChanged, 57))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::FinishTimestampChanged, 58))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::FinishTimestampMonotonicChanged, 59))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::FirmwareTimestampChanged, 60))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::FirmwareTimestampMonotonicChanged, 61))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::GeneratorsFinishTimestampChanged, 62))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::GeneratorsFinishTimestampMonotonicChanged, 63))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::GeneratorsStartTimestampChanged, 64))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::GeneratorsStartTimestampMonotonicChanged, 65))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDGeneratorsFinishTimestampChanged, 66))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDGeneratorsFinishTimestampMonotonicChanged, 67))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDGeneratorsStartTimestampChanged, 68))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDGeneratorsStartTimestampMonotonicChanged, 69))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDSecurityFinishTimestampChanged, 70))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDSecurityFinishTimestampMonotonicChanged, 71))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDSecurityStartTimestampChanged, 72))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDSecurityStartTimestampMonotonicChanged, 73))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDTimestampChanged, 74))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDTimestampMonotonicChanged, 75))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDUnitsLoadFinishTimestampChanged, 76))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDUnitsLoadFinishTimestampMonotonicChanged, 77))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDUnitsLoadStartTimestampChanged, 78))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::InitRDUnitsLoadStartTimestampMonotonicChanged, 79))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::KernelTimestampChanged, 80))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::KernelTimestampMonotonicChanged, 81))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::LoaderTimestampChanged, 82))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::LoaderTimestampMonotonicChanged, 83))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QString & ) const>(_a, &__Systemd1Manager::LogLevelChanged, 84))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QString & ) const>(_a, &__Systemd1Manager::LogTargetChanged, 85))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(uint ) const>(_a, &__Systemd1Manager::NFailedJobsChanged, 86))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(uint ) const>(_a, &__Systemd1Manager::NFailedUnitsChanged, 87))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(uint ) const>(_a, &__Systemd1Manager::NInstalledJobsChanged, 88))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(uint ) const>(_a, &__Systemd1Manager::NJobsChanged, 89))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(uint ) const>(_a, &__Systemd1Manager::NNamesChanged, 90))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(double ) const>(_a, &__Systemd1Manager::ProgressChanged, 91))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::RuntimeWatchdogUSecChanged, 92))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::SecurityFinishTimestampChanged, 93))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::SecurityFinishTimestampMonotonicChanged, 94))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::SecurityStartTimestampChanged, 95))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::SecurityStartTimestampMonotonicChanged, 96))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(bool ) const>(_a, &__Systemd1Manager::ServiceWatchdogsChanged, 97))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(bool ) const>(_a, &__Systemd1Manager::ShowStatusChanged, 98))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::ShutdownWatchdogUSecChanged, 99))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QString & ) const>(_a, &__Systemd1Manager::SystemStateChanged, 100))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QString & ) const>(_a, &__Systemd1Manager::TaintedChanged, 101))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::TimerSlackNSecChanged, 102))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QStringList & ) const>(_a, &__Systemd1Manager::UnitPathChanged, 103))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::UnitsLoadFinishTimestampChanged, 104))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::UnitsLoadFinishTimestampMonotonicChanged, 105))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::UnitsLoadStartTimestampChanged, 106))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::UnitsLoadStartTimestampMonotonicChanged, 107))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::UserspaceTimestampChanged, 108))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(qulonglong ) const>(_a, &__Systemd1Manager::UserspaceTimestampMonotonicChanged, 109))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QString & ) const>(_a, &__Systemd1Manager::VersionChanged, 110))
            return;
        if (QtMocHelpers::indexOfMethod<void (__Systemd1Manager::*)(const QString & ) const>(_a, &__Systemd1Manager::VirtualizationChanged, 111))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->architecture(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->confirmSpawn(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->controlGroup(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->defaultBlockIOAccounting(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->defaultCPUAccounting(); break;
        case 5: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitAS(); break;
        case 6: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitASSoft(); break;
        case 7: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitCORE(); break;
        case 8: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitCORESoft(); break;
        case 9: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitCPU(); break;
        case 10: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitCPUSoft(); break;
        case 11: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitDATA(); break;
        case 12: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitDATASoft(); break;
        case 13: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitFSIZE(); break;
        case 14: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitFSIZESoft(); break;
        case 15: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitLOCKS(); break;
        case 16: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitLOCKSSoft(); break;
        case 17: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitMEMLOCK(); break;
        case 18: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitMEMLOCKSoft(); break;
        case 19: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitMSGQUEUE(); break;
        case 20: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitMSGQUEUESoft(); break;
        case 21: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitNICE(); break;
        case 22: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitNICESoft(); break;
        case 23: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitNOFILE(); break;
        case 24: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitNOFILESoft(); break;
        case 25: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitNPROC(); break;
        case 26: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitNPROCSoft(); break;
        case 27: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitRSS(); break;
        case 28: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitRSSSoft(); break;
        case 29: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitRTPRIO(); break;
        case 30: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitRTPRIOSoft(); break;
        case 31: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitRTTIME(); break;
        case 32: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitRTTIMESoft(); break;
        case 33: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitSIGPENDING(); break;
        case 34: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitSIGPENDINGSoft(); break;
        case 35: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitSTACK(); break;
        case 36: *reinterpret_cast<qulonglong*>(_v) = _t->defaultLimitSTACKSoft(); break;
        case 37: *reinterpret_cast<bool*>(_v) = _t->defaultMemoryAccounting(); break;
        case 38: *reinterpret_cast<qulonglong*>(_v) = _t->defaultRestartUSec(); break;
        case 39: *reinterpret_cast<QString*>(_v) = _t->defaultStandardError(); break;
        case 40: *reinterpret_cast<QString*>(_v) = _t->defaultStandardOutput(); break;
        case 41: *reinterpret_cast<uint*>(_v) = _t->defaultStartLimitBurst(); break;
        case 42: *reinterpret_cast<qulonglong*>(_v) = _t->defaultStartLimitIntervalUSec(); break;
        case 43: *reinterpret_cast<bool*>(_v) = _t->defaultTasksAccounting(); break;
        case 44: *reinterpret_cast<qulonglong*>(_v) = _t->defaultTasksMax(); break;
        case 45: *reinterpret_cast<qulonglong*>(_v) = _t->defaultTimeoutStartUSec(); break;
        case 46: *reinterpret_cast<qulonglong*>(_v) = _t->defaultTimeoutStopUSec(); break;
        case 47: *reinterpret_cast<qulonglong*>(_v) = _t->defaultTimerAccuracyUSec(); break;
        case 48: *reinterpret_cast<QStringList*>(_v) = _t->environment(); break;
        case 49: *reinterpret_cast<uchar*>(_v) = _t->exitCode(); break;
        case 50: *reinterpret_cast<QString*>(_v) = _t->features(); break;
        case 51: *reinterpret_cast<qulonglong*>(_v) = _t->finishTimestamp(); break;
        case 52: *reinterpret_cast<qulonglong*>(_v) = _t->finishTimestampMonotonic(); break;
        case 53: *reinterpret_cast<qulonglong*>(_v) = _t->firmwareTimestamp(); break;
        case 54: *reinterpret_cast<qulonglong*>(_v) = _t->firmwareTimestampMonotonic(); break;
        case 55: *reinterpret_cast<qulonglong*>(_v) = _t->generatorsFinishTimestamp(); break;
        case 56: *reinterpret_cast<qulonglong*>(_v) = _t->generatorsFinishTimestampMonotonic(); break;
        case 57: *reinterpret_cast<qulonglong*>(_v) = _t->generatorsStartTimestamp(); break;
        case 58: *reinterpret_cast<qulonglong*>(_v) = _t->generatorsStartTimestampMonotonic(); break;
        case 59: *reinterpret_cast<qulonglong*>(_v) = _t->initRDGeneratorsFinishTimestamp(); break;
        case 60: *reinterpret_cast<qulonglong*>(_v) = _t->initRDGeneratorsFinishTimestampMonotonic(); break;
        case 61: *reinterpret_cast<qulonglong*>(_v) = _t->initRDGeneratorsStartTimestamp(); break;
        case 62: *reinterpret_cast<qulonglong*>(_v) = _t->initRDGeneratorsStartTimestampMonotonic(); break;
        case 63: *reinterpret_cast<qulonglong*>(_v) = _t->initRDSecurityFinishTimestamp(); break;
        case 64: *reinterpret_cast<qulonglong*>(_v) = _t->initRDSecurityFinishTimestampMonotonic(); break;
        case 65: *reinterpret_cast<qulonglong*>(_v) = _t->initRDSecurityStartTimestamp(); break;
        case 66: *reinterpret_cast<qulonglong*>(_v) = _t->initRDSecurityStartTimestampMonotonic(); break;
        case 67: *reinterpret_cast<qulonglong*>(_v) = _t->initRDTimestamp(); break;
        case 68: *reinterpret_cast<qulonglong*>(_v) = _t->initRDTimestampMonotonic(); break;
        case 69: *reinterpret_cast<qulonglong*>(_v) = _t->initRDUnitsLoadFinishTimestamp(); break;
        case 70: *reinterpret_cast<qulonglong*>(_v) = _t->initRDUnitsLoadFinishTimestampMonotonic(); break;
        case 71: *reinterpret_cast<qulonglong*>(_v) = _t->initRDUnitsLoadStartTimestamp(); break;
        case 72: *reinterpret_cast<qulonglong*>(_v) = _t->initRDUnitsLoadStartTimestampMonotonic(); break;
        case 73: *reinterpret_cast<qulonglong*>(_v) = _t->kernelTimestamp(); break;
        case 74: *reinterpret_cast<qulonglong*>(_v) = _t->kernelTimestampMonotonic(); break;
        case 75: *reinterpret_cast<qulonglong*>(_v) = _t->loaderTimestamp(); break;
        case 76: *reinterpret_cast<qulonglong*>(_v) = _t->loaderTimestampMonotonic(); break;
        case 77: *reinterpret_cast<QString*>(_v) = _t->logLevel(); break;
        case 78: *reinterpret_cast<QString*>(_v) = _t->logTarget(); break;
        case 79: *reinterpret_cast<uint*>(_v) = _t->nFailedJobs(); break;
        case 80: *reinterpret_cast<uint*>(_v) = _t->nFailedUnits(); break;
        case 81: *reinterpret_cast<uint*>(_v) = _t->nInstalledJobs(); break;
        case 82: *reinterpret_cast<uint*>(_v) = _t->nJobs(); break;
        case 83: *reinterpret_cast<uint*>(_v) = _t->nNames(); break;
        case 84: *reinterpret_cast<double*>(_v) = _t->progress(); break;
        case 85: *reinterpret_cast<qulonglong*>(_v) = _t->runtimeWatchdogUSec(); break;
        case 86: *reinterpret_cast<qulonglong*>(_v) = _t->securityFinishTimestamp(); break;
        case 87: *reinterpret_cast<qulonglong*>(_v) = _t->securityFinishTimestampMonotonic(); break;
        case 88: *reinterpret_cast<qulonglong*>(_v) = _t->securityStartTimestamp(); break;
        case 89: *reinterpret_cast<qulonglong*>(_v) = _t->securityStartTimestampMonotonic(); break;
        case 90: *reinterpret_cast<bool*>(_v) = _t->serviceWatchdogs(); break;
        case 91: *reinterpret_cast<bool*>(_v) = _t->showStatus(); break;
        case 92: *reinterpret_cast<qulonglong*>(_v) = _t->shutdownWatchdogUSec(); break;
        case 93: *reinterpret_cast<QString*>(_v) = _t->systemState(); break;
        case 94: *reinterpret_cast<QString*>(_v) = _t->tainted(); break;
        case 95: *reinterpret_cast<qulonglong*>(_v) = _t->timerSlackNSec(); break;
        case 96: *reinterpret_cast<QStringList*>(_v) = _t->unitPath(); break;
        case 97: *reinterpret_cast<qulonglong*>(_v) = _t->unitsLoadFinishTimestamp(); break;
        case 98: *reinterpret_cast<qulonglong*>(_v) = _t->unitsLoadFinishTimestampMonotonic(); break;
        case 99: *reinterpret_cast<qulonglong*>(_v) = _t->unitsLoadStartTimestamp(); break;
        case 100: *reinterpret_cast<qulonglong*>(_v) = _t->unitsLoadStartTimestampMonotonic(); break;
        case 101: *reinterpret_cast<qulonglong*>(_v) = _t->userspaceTimestamp(); break;
        case 102: *reinterpret_cast<qulonglong*>(_v) = _t->userspaceTimestampMonotonic(); break;
        case 103: *reinterpret_cast<QString*>(_v) = _t->version(); break;
        case 104: *reinterpret_cast<QString*>(_v) = _t->virtualization(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 77: _t->setLogLevel(*reinterpret_cast<QString*>(_v)); break;
        case 78: _t->setLogTarget(*reinterpret_cast<QString*>(_v)); break;
        case 85: _t->setRuntimeWatchdogUSec(*reinterpret_cast<qulonglong*>(_v)); break;
        case 90: _t->setServiceWatchdogs(*reinterpret_cast<bool*>(_v)); break;
        case 92: _t->setShutdownWatchdogUSec(*reinterpret_cast<qulonglong*>(_v)); break;
        default: break;
        }
    }
}

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

void *__Systemd1Manager::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17__Systemd1ManagerE_t>.strings))
        return static_cast<void*>(this);
    return Dtk::Core::DDBusExtendedAbstractInterface::qt_metacast(_clname);
}

int __Systemd1Manager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Dtk::Core::DDBusExtendedAbstractInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 175)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 175;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 175)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 175;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 105;
    }
    return _id;
}

// SIGNAL 0
void __Systemd1Manager::JobNew(uint _t1, const QDBusObjectPath & _t2, const QString & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2, _t3);
}

// SIGNAL 1
void __Systemd1Manager::JobRemoved(uint _t1, const QDBusObjectPath & _t2, const QString & _t3, const QString & _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 2
void __Systemd1Manager::Reloading(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void __Systemd1Manager::StartupFinished(qulonglong _t1, qulonglong _t2, qulonglong _t3, qulonglong _t4, qulonglong _t5, qulonglong _t6)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1, _t2, _t3, _t4, _t5, _t6);
}

// SIGNAL 4
void __Systemd1Manager::UnitFilesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void __Systemd1Manager::UnitNew(const QString & _t1, const QDBusObjectPath & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1, _t2);
}

// SIGNAL 6
void __Systemd1Manager::UnitRemoved(const QString & _t1, const QDBusObjectPath & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1, _t2);
}

// SIGNAL 7
void __Systemd1Manager::ArchitectureChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void __Systemd1Manager::ConfirmSpawnChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void __Systemd1Manager::ControlGroupChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void __Systemd1Manager::DefaultBlockIOAccountingChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void __Systemd1Manager::DefaultCPUAccountingChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void __Systemd1Manager::DefaultLimitASChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void __Systemd1Manager::DefaultLimitASSoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void __Systemd1Manager::DefaultLimitCOREChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void __Systemd1Manager::DefaultLimitCORESoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void __Systemd1Manager::DefaultLimitCPUChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void __Systemd1Manager::DefaultLimitCPUSoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void __Systemd1Manager::DefaultLimitDATAChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void __Systemd1Manager::DefaultLimitDATASoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void __Systemd1Manager::DefaultLimitFSIZEChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void __Systemd1Manager::DefaultLimitFSIZESoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void __Systemd1Manager::DefaultLimitLOCKSChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void __Systemd1Manager::DefaultLimitLOCKSSoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void __Systemd1Manager::DefaultLimitMEMLOCKChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void __Systemd1Manager::DefaultLimitMEMLOCKSoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void __Systemd1Manager::DefaultLimitMSGQUEUEChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void __Systemd1Manager::DefaultLimitMSGQUEUESoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 27, nullptr, _t1);
}

// SIGNAL 28
void __Systemd1Manager::DefaultLimitNICEChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void __Systemd1Manager::DefaultLimitNICESoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 29, nullptr, _t1);
}

// SIGNAL 30
void __Systemd1Manager::DefaultLimitNOFILEChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 30, nullptr, _t1);
}

// SIGNAL 31
void __Systemd1Manager::DefaultLimitNOFILESoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 31, nullptr, _t1);
}

// SIGNAL 32
void __Systemd1Manager::DefaultLimitNPROCChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 32, nullptr, _t1);
}

// SIGNAL 33
void __Systemd1Manager::DefaultLimitNPROCSoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 33, nullptr, _t1);
}

// SIGNAL 34
void __Systemd1Manager::DefaultLimitRSSChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 34, nullptr, _t1);
}

// SIGNAL 35
void __Systemd1Manager::DefaultLimitRSSSoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 35, nullptr, _t1);
}

// SIGNAL 36
void __Systemd1Manager::DefaultLimitRTPRIOChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 36, nullptr, _t1);
}

// SIGNAL 37
void __Systemd1Manager::DefaultLimitRTPRIOSoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 37, nullptr, _t1);
}

// SIGNAL 38
void __Systemd1Manager::DefaultLimitRTTIMEChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 38, nullptr, _t1);
}

// SIGNAL 39
void __Systemd1Manager::DefaultLimitRTTIMESoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 39, nullptr, _t1);
}

// SIGNAL 40
void __Systemd1Manager::DefaultLimitSIGPENDINGChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 40, nullptr, _t1);
}

// SIGNAL 41
void __Systemd1Manager::DefaultLimitSIGPENDINGSoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 41, nullptr, _t1);
}

// SIGNAL 42
void __Systemd1Manager::DefaultLimitSTACKChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 42, nullptr, _t1);
}

// SIGNAL 43
void __Systemd1Manager::DefaultLimitSTACKSoftChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 43, nullptr, _t1);
}

// SIGNAL 44
void __Systemd1Manager::DefaultMemoryAccountingChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 44, nullptr, _t1);
}

// SIGNAL 45
void __Systemd1Manager::DefaultRestartUSecChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 45, nullptr, _t1);
}

// SIGNAL 46
void __Systemd1Manager::DefaultStandardErrorChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 46, nullptr, _t1);
}

// SIGNAL 47
void __Systemd1Manager::DefaultStandardOutputChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 47, nullptr, _t1);
}

// SIGNAL 48
void __Systemd1Manager::DefaultStartLimitBurstChanged(uint _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 48, nullptr, _t1);
}

// SIGNAL 49
void __Systemd1Manager::DefaultStartLimitIntervalUSecChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 49, nullptr, _t1);
}

// SIGNAL 50
void __Systemd1Manager::DefaultTasksAccountingChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 50, nullptr, _t1);
}

// SIGNAL 51
void __Systemd1Manager::DefaultTasksMaxChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 51, nullptr, _t1);
}

// SIGNAL 52
void __Systemd1Manager::DefaultTimeoutStartUSecChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 52, nullptr, _t1);
}

// SIGNAL 53
void __Systemd1Manager::DefaultTimeoutStopUSecChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 53, nullptr, _t1);
}

// SIGNAL 54
void __Systemd1Manager::DefaultTimerAccuracyUSecChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 54, nullptr, _t1);
}

// SIGNAL 55
void __Systemd1Manager::EnvironmentChanged(const QStringList & _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 55, nullptr, _t1);
}

// SIGNAL 56
void __Systemd1Manager::ExitCodeChanged(uchar _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 56, nullptr, _t1);
}

// SIGNAL 57
void __Systemd1Manager::FeaturesChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 57, nullptr, _t1);
}

// SIGNAL 58
void __Systemd1Manager::FinishTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 58, nullptr, _t1);
}

// SIGNAL 59
void __Systemd1Manager::FinishTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 59, nullptr, _t1);
}

// SIGNAL 60
void __Systemd1Manager::FirmwareTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 60, nullptr, _t1);
}

// SIGNAL 61
void __Systemd1Manager::FirmwareTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 61, nullptr, _t1);
}

// SIGNAL 62
void __Systemd1Manager::GeneratorsFinishTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 62, nullptr, _t1);
}

// SIGNAL 63
void __Systemd1Manager::GeneratorsFinishTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 63, nullptr, _t1);
}

// SIGNAL 64
void __Systemd1Manager::GeneratorsStartTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 64, nullptr, _t1);
}

// SIGNAL 65
void __Systemd1Manager::GeneratorsStartTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 65, nullptr, _t1);
}

// SIGNAL 66
void __Systemd1Manager::InitRDGeneratorsFinishTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 66, nullptr, _t1);
}

// SIGNAL 67
void __Systemd1Manager::InitRDGeneratorsFinishTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 67, nullptr, _t1);
}

// SIGNAL 68
void __Systemd1Manager::InitRDGeneratorsStartTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 68, nullptr, _t1);
}

// SIGNAL 69
void __Systemd1Manager::InitRDGeneratorsStartTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 69, nullptr, _t1);
}

// SIGNAL 70
void __Systemd1Manager::InitRDSecurityFinishTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 70, nullptr, _t1);
}

// SIGNAL 71
void __Systemd1Manager::InitRDSecurityFinishTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 71, nullptr, _t1);
}

// SIGNAL 72
void __Systemd1Manager::InitRDSecurityStartTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 72, nullptr, _t1);
}

// SIGNAL 73
void __Systemd1Manager::InitRDSecurityStartTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 73, nullptr, _t1);
}

// SIGNAL 74
void __Systemd1Manager::InitRDTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 74, nullptr, _t1);
}

// SIGNAL 75
void __Systemd1Manager::InitRDTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 75, nullptr, _t1);
}

// SIGNAL 76
void __Systemd1Manager::InitRDUnitsLoadFinishTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 76, nullptr, _t1);
}

// SIGNAL 77
void __Systemd1Manager::InitRDUnitsLoadFinishTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 77, nullptr, _t1);
}

// SIGNAL 78
void __Systemd1Manager::InitRDUnitsLoadStartTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 78, nullptr, _t1);
}

// SIGNAL 79
void __Systemd1Manager::InitRDUnitsLoadStartTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 79, nullptr, _t1);
}

// SIGNAL 80
void __Systemd1Manager::KernelTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 80, nullptr, _t1);
}

// SIGNAL 81
void __Systemd1Manager::KernelTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 81, nullptr, _t1);
}

// SIGNAL 82
void __Systemd1Manager::LoaderTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 82, nullptr, _t1);
}

// SIGNAL 83
void __Systemd1Manager::LoaderTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 83, nullptr, _t1);
}

// SIGNAL 84
void __Systemd1Manager::LogLevelChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 84, nullptr, _t1);
}

// SIGNAL 85
void __Systemd1Manager::LogTargetChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 85, nullptr, _t1);
}

// SIGNAL 86
void __Systemd1Manager::NFailedJobsChanged(uint _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 86, nullptr, _t1);
}

// SIGNAL 87
void __Systemd1Manager::NFailedUnitsChanged(uint _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 87, nullptr, _t1);
}

// SIGNAL 88
void __Systemd1Manager::NInstalledJobsChanged(uint _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 88, nullptr, _t1);
}

// SIGNAL 89
void __Systemd1Manager::NJobsChanged(uint _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 89, nullptr, _t1);
}

// SIGNAL 90
void __Systemd1Manager::NNamesChanged(uint _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 90, nullptr, _t1);
}

// SIGNAL 91
void __Systemd1Manager::ProgressChanged(double _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 91, nullptr, _t1);
}

// SIGNAL 92
void __Systemd1Manager::RuntimeWatchdogUSecChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 92, nullptr, _t1);
}

// SIGNAL 93
void __Systemd1Manager::SecurityFinishTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 93, nullptr, _t1);
}

// SIGNAL 94
void __Systemd1Manager::SecurityFinishTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 94, nullptr, _t1);
}

// SIGNAL 95
void __Systemd1Manager::SecurityStartTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 95, nullptr, _t1);
}

// SIGNAL 96
void __Systemd1Manager::SecurityStartTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 96, nullptr, _t1);
}

// SIGNAL 97
void __Systemd1Manager::ServiceWatchdogsChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 97, nullptr, _t1);
}

// SIGNAL 98
void __Systemd1Manager::ShowStatusChanged(bool _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 98, nullptr, _t1);
}

// SIGNAL 99
void __Systemd1Manager::ShutdownWatchdogUSecChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 99, nullptr, _t1);
}

// SIGNAL 100
void __Systemd1Manager::SystemStateChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 100, nullptr, _t1);
}

// SIGNAL 101
void __Systemd1Manager::TaintedChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 101, nullptr, _t1);
}

// SIGNAL 102
void __Systemd1Manager::TimerSlackNSecChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 102, nullptr, _t1);
}

// SIGNAL 103
void __Systemd1Manager::UnitPathChanged(const QStringList & _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 103, nullptr, _t1);
}

// SIGNAL 104
void __Systemd1Manager::UnitsLoadFinishTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 104, nullptr, _t1);
}

// SIGNAL 105
void __Systemd1Manager::UnitsLoadFinishTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 105, nullptr, _t1);
}

// SIGNAL 106
void __Systemd1Manager::UnitsLoadStartTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 106, nullptr, _t1);
}

// SIGNAL 107
void __Systemd1Manager::UnitsLoadStartTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 107, nullptr, _t1);
}

// SIGNAL 108
void __Systemd1Manager::UserspaceTimestampChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 108, nullptr, _t1);
}

// SIGNAL 109
void __Systemd1Manager::UserspaceTimestampMonotonicChanged(qulonglong _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 109, nullptr, _t1);
}

// SIGNAL 110
void __Systemd1Manager::VersionChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 110, nullptr, _t1);
}

// SIGNAL 111
void __Systemd1Manager::VirtualizationChanged(const QString & _t1)const
{
    QMetaObject::activate<void>(const_cast< __Systemd1Manager *>(this), &staticMetaObject, 111, nullptr, _t1);
}
QT_WARNING_POP
