/*
 * This file was generated by qdbusxml2cpp-fix version 0.8
 * Command line was: qdbusxml2cpp-fix -c Systemd1Manager -p /build/deepin-session/src/dde-session/dbusinterface/org_freedesktop_systemd1_Manager /build/deepin-session/src/dde-session/dbus/interface/org.freedesktop.systemd1.Manager.xml
 *
 * qdbusxml2cpp-fix is Copyright (C) 2016 Deepin Technology Co., Ltd.
 *
 * This is an auto-generated file.
 * This file may have been hand-edited. Look for HAND-EDIT comments
 * before re-generating it.
 */

#include "/build/deepin-session/src/dde-session/dbusinterface/org_freedesktop_systemd1_Manager.h"

DCORE_USE_NAMESPACE
/*
 * Implementation of interface class __Systemd1Manager
 */

class __Systemd1ManagerPrivate
{
public:
   __Systemd1ManagerPrivate() = default;

    // begin member variables
    QString Architecture;
    bool ConfirmSpawn;
    QString ControlGroup;
    bool DefaultBlockIOAccounting;
    bool DefaultCPUAccounting;
    qulonglong DefaultLimitAS;
    qulonglong DefaultLimitASSoft;
    qulonglong DefaultLimitCORE;
    qulonglong DefaultLimitCORESoft;
    qulonglong DefaultLimitCPU;
    qulonglong DefaultLimitCPUSoft;
    qulonglong DefaultLimitDATA;
    qulonglong DefaultLimitDATASoft;
    qulonglong DefaultLimitFSIZE;
    qulonglong DefaultLimitFSIZESoft;
    qulonglong DefaultLimitLOCKS;
    qulonglong DefaultLimitLOCKSSoft;
    qulonglong DefaultLimitMEMLOCK;
    qulonglong DefaultLimitMEMLOCKSoft;
    qulonglong DefaultLimitMSGQUEUE;
    qulonglong DefaultLimitMSGQUEUESoft;
    qulonglong DefaultLimitNICE;
    qulonglong DefaultLimitNICESoft;
    qulonglong DefaultLimitNOFILE;
    qulonglong DefaultLimitNOFILESoft;
    qulonglong DefaultLimitNPROC;
    qulonglong DefaultLimitNPROCSoft;
    qulonglong DefaultLimitRSS;
    qulonglong DefaultLimitRSSSoft;
    qulonglong DefaultLimitRTPRIO;
    qulonglong DefaultLimitRTPRIOSoft;
    qulonglong DefaultLimitRTTIME;
    qulonglong DefaultLimitRTTIMESoft;
    qulonglong DefaultLimitSIGPENDING;
    qulonglong DefaultLimitSIGPENDINGSoft;
    qulonglong DefaultLimitSTACK;
    qulonglong DefaultLimitSTACKSoft;
    bool DefaultMemoryAccounting;
    qulonglong DefaultRestartUSec;
    QString DefaultStandardError;
    QString DefaultStandardOutput;
    uint DefaultStartLimitBurst;
    qulonglong DefaultStartLimitIntervalUSec;
    bool DefaultTasksAccounting;
    qulonglong DefaultTasksMax;
    qulonglong DefaultTimeoutStartUSec;
    qulonglong DefaultTimeoutStopUSec;
    qulonglong DefaultTimerAccuracyUSec;
    QStringList Environment;
    uchar ExitCode;
    QString Features;
    qulonglong FinishTimestamp;
    qulonglong FinishTimestampMonotonic;
    qulonglong FirmwareTimestamp;
    qulonglong FirmwareTimestampMonotonic;
    qulonglong GeneratorsFinishTimestamp;
    qulonglong GeneratorsFinishTimestampMonotonic;
    qulonglong GeneratorsStartTimestamp;
    qulonglong GeneratorsStartTimestampMonotonic;
    qulonglong InitRDGeneratorsFinishTimestamp;
    qulonglong InitRDGeneratorsFinishTimestampMonotonic;
    qulonglong InitRDGeneratorsStartTimestamp;
    qulonglong InitRDGeneratorsStartTimestampMonotonic;
    qulonglong InitRDSecurityFinishTimestamp;
    qulonglong InitRDSecurityFinishTimestampMonotonic;
    qulonglong InitRDSecurityStartTimestamp;
    qulonglong InitRDSecurityStartTimestampMonotonic;
    qulonglong InitRDTimestamp;
    qulonglong InitRDTimestampMonotonic;
    qulonglong InitRDUnitsLoadFinishTimestamp;
    qulonglong InitRDUnitsLoadFinishTimestampMonotonic;
    qulonglong InitRDUnitsLoadStartTimestamp;
    qulonglong InitRDUnitsLoadStartTimestampMonotonic;
    qulonglong KernelTimestamp;
    qulonglong KernelTimestampMonotonic;
    qulonglong LoaderTimestamp;
    qulonglong LoaderTimestampMonotonic;
    QString LogLevel;
    QString LogTarget;
    uint NFailedJobs;
    uint NFailedUnits;
    uint NInstalledJobs;
    uint NJobs;
    uint NNames;
    double Progress;
    qulonglong RuntimeWatchdogUSec;
    qulonglong SecurityFinishTimestamp;
    qulonglong SecurityFinishTimestampMonotonic;
    qulonglong SecurityStartTimestamp;
    qulonglong SecurityStartTimestampMonotonic;
    bool ServiceWatchdogs;
    bool ShowStatus;
    qulonglong ShutdownWatchdogUSec;
    QString SystemState;
    QString Tainted;
    qulonglong TimerSlackNSec;
    QStringList UnitPath;
    qulonglong UnitsLoadFinishTimestamp;
    qulonglong UnitsLoadFinishTimestampMonotonic;
    qulonglong UnitsLoadStartTimestamp;
    qulonglong UnitsLoadStartTimestampMonotonic;
    qulonglong UserspaceTimestamp;
    qulonglong UserspaceTimestampMonotonic;
    QString Version;
    QString Virtualization;

public:
    QMap<QString, QDBusPendingCallWatcher *> m_processingCalls;
    QMap<QString, QList<QVariant>> m_waittingCalls;
};

__Systemd1Manager::__Systemd1Manager(const QString &service, const QString &path, const QDBusConnection &connection, QObject *parent)
    : DDBusExtendedAbstractInterface(service, path, staticInterfaceName(), connection, parent)
    , d_ptr(new __Systemd1ManagerPrivate)
{
    connect(this, &__Systemd1Manager::propertyChanged, this, &__Systemd1Manager::onPropertyChanged);

    if (QMetaType::fromName("StringStructList").id() == QMetaType::UnknownType)
        registerStringStructListMetaType();
}

__Systemd1Manager::~__Systemd1Manager()
{
    qDeleteAll(d_ptr->m_processingCalls.values());
    delete d_ptr;
}

void __Systemd1Manager::onPropertyChanged(const QString &propName, const QVariant &value)
{
    if (propName == QStringLiteral("Architecture"))
    {
        const QString &Architecture = qvariant_cast<QString>(value);
        if (d_ptr->Architecture != Architecture)
        {
            d_ptr->Architecture = Architecture;
            Q_EMIT ArchitectureChanged(d_ptr->Architecture);
        }
        return;
    }

    if (propName == QStringLiteral("ConfirmSpawn"))
    {
        const bool &ConfirmSpawn = qvariant_cast<bool>(value);
        if (d_ptr->ConfirmSpawn != ConfirmSpawn)
        {
            d_ptr->ConfirmSpawn = ConfirmSpawn;
            Q_EMIT ConfirmSpawnChanged(d_ptr->ConfirmSpawn);
        }
        return;
    }

    if (propName == QStringLiteral("ControlGroup"))
    {
        const QString &ControlGroup = qvariant_cast<QString>(value);
        if (d_ptr->ControlGroup != ControlGroup)
        {
            d_ptr->ControlGroup = ControlGroup;
            Q_EMIT ControlGroupChanged(d_ptr->ControlGroup);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultBlockIOAccounting"))
    {
        const bool &DefaultBlockIOAccounting = qvariant_cast<bool>(value);
        if (d_ptr->DefaultBlockIOAccounting != DefaultBlockIOAccounting)
        {
            d_ptr->DefaultBlockIOAccounting = DefaultBlockIOAccounting;
            Q_EMIT DefaultBlockIOAccountingChanged(d_ptr->DefaultBlockIOAccounting);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultCPUAccounting"))
    {
        const bool &DefaultCPUAccounting = qvariant_cast<bool>(value);
        if (d_ptr->DefaultCPUAccounting != DefaultCPUAccounting)
        {
            d_ptr->DefaultCPUAccounting = DefaultCPUAccounting;
            Q_EMIT DefaultCPUAccountingChanged(d_ptr->DefaultCPUAccounting);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitAS"))
    {
        const qulonglong &DefaultLimitAS = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitAS != DefaultLimitAS)
        {
            d_ptr->DefaultLimitAS = DefaultLimitAS;
            Q_EMIT DefaultLimitASChanged(d_ptr->DefaultLimitAS);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitASSoft"))
    {
        const qulonglong &DefaultLimitASSoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitASSoft != DefaultLimitASSoft)
        {
            d_ptr->DefaultLimitASSoft = DefaultLimitASSoft;
            Q_EMIT DefaultLimitASSoftChanged(d_ptr->DefaultLimitASSoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitCORE"))
    {
        const qulonglong &DefaultLimitCORE = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitCORE != DefaultLimitCORE)
        {
            d_ptr->DefaultLimitCORE = DefaultLimitCORE;
            Q_EMIT DefaultLimitCOREChanged(d_ptr->DefaultLimitCORE);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitCORESoft"))
    {
        const qulonglong &DefaultLimitCORESoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitCORESoft != DefaultLimitCORESoft)
        {
            d_ptr->DefaultLimitCORESoft = DefaultLimitCORESoft;
            Q_EMIT DefaultLimitCORESoftChanged(d_ptr->DefaultLimitCORESoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitCPU"))
    {
        const qulonglong &DefaultLimitCPU = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitCPU != DefaultLimitCPU)
        {
            d_ptr->DefaultLimitCPU = DefaultLimitCPU;
            Q_EMIT DefaultLimitCPUChanged(d_ptr->DefaultLimitCPU);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitCPUSoft"))
    {
        const qulonglong &DefaultLimitCPUSoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitCPUSoft != DefaultLimitCPUSoft)
        {
            d_ptr->DefaultLimitCPUSoft = DefaultLimitCPUSoft;
            Q_EMIT DefaultLimitCPUSoftChanged(d_ptr->DefaultLimitCPUSoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitDATA"))
    {
        const qulonglong &DefaultLimitDATA = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitDATA != DefaultLimitDATA)
        {
            d_ptr->DefaultLimitDATA = DefaultLimitDATA;
            Q_EMIT DefaultLimitDATAChanged(d_ptr->DefaultLimitDATA);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitDATASoft"))
    {
        const qulonglong &DefaultLimitDATASoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitDATASoft != DefaultLimitDATASoft)
        {
            d_ptr->DefaultLimitDATASoft = DefaultLimitDATASoft;
            Q_EMIT DefaultLimitDATASoftChanged(d_ptr->DefaultLimitDATASoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitFSIZE"))
    {
        const qulonglong &DefaultLimitFSIZE = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitFSIZE != DefaultLimitFSIZE)
        {
            d_ptr->DefaultLimitFSIZE = DefaultLimitFSIZE;
            Q_EMIT DefaultLimitFSIZEChanged(d_ptr->DefaultLimitFSIZE);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitFSIZESoft"))
    {
        const qulonglong &DefaultLimitFSIZESoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitFSIZESoft != DefaultLimitFSIZESoft)
        {
            d_ptr->DefaultLimitFSIZESoft = DefaultLimitFSIZESoft;
            Q_EMIT DefaultLimitFSIZESoftChanged(d_ptr->DefaultLimitFSIZESoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitLOCKS"))
    {
        const qulonglong &DefaultLimitLOCKS = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitLOCKS != DefaultLimitLOCKS)
        {
            d_ptr->DefaultLimitLOCKS = DefaultLimitLOCKS;
            Q_EMIT DefaultLimitLOCKSChanged(d_ptr->DefaultLimitLOCKS);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitLOCKSSoft"))
    {
        const qulonglong &DefaultLimitLOCKSSoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitLOCKSSoft != DefaultLimitLOCKSSoft)
        {
            d_ptr->DefaultLimitLOCKSSoft = DefaultLimitLOCKSSoft;
            Q_EMIT DefaultLimitLOCKSSoftChanged(d_ptr->DefaultLimitLOCKSSoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitMEMLOCK"))
    {
        const qulonglong &DefaultLimitMEMLOCK = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitMEMLOCK != DefaultLimitMEMLOCK)
        {
            d_ptr->DefaultLimitMEMLOCK = DefaultLimitMEMLOCK;
            Q_EMIT DefaultLimitMEMLOCKChanged(d_ptr->DefaultLimitMEMLOCK);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitMEMLOCKSoft"))
    {
        const qulonglong &DefaultLimitMEMLOCKSoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitMEMLOCKSoft != DefaultLimitMEMLOCKSoft)
        {
            d_ptr->DefaultLimitMEMLOCKSoft = DefaultLimitMEMLOCKSoft;
            Q_EMIT DefaultLimitMEMLOCKSoftChanged(d_ptr->DefaultLimitMEMLOCKSoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitMSGQUEUE"))
    {
        const qulonglong &DefaultLimitMSGQUEUE = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitMSGQUEUE != DefaultLimitMSGQUEUE)
        {
            d_ptr->DefaultLimitMSGQUEUE = DefaultLimitMSGQUEUE;
            Q_EMIT DefaultLimitMSGQUEUEChanged(d_ptr->DefaultLimitMSGQUEUE);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitMSGQUEUESoft"))
    {
        const qulonglong &DefaultLimitMSGQUEUESoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitMSGQUEUESoft != DefaultLimitMSGQUEUESoft)
        {
            d_ptr->DefaultLimitMSGQUEUESoft = DefaultLimitMSGQUEUESoft;
            Q_EMIT DefaultLimitMSGQUEUESoftChanged(d_ptr->DefaultLimitMSGQUEUESoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitNICE"))
    {
        const qulonglong &DefaultLimitNICE = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitNICE != DefaultLimitNICE)
        {
            d_ptr->DefaultLimitNICE = DefaultLimitNICE;
            Q_EMIT DefaultLimitNICEChanged(d_ptr->DefaultLimitNICE);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitNICESoft"))
    {
        const qulonglong &DefaultLimitNICESoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitNICESoft != DefaultLimitNICESoft)
        {
            d_ptr->DefaultLimitNICESoft = DefaultLimitNICESoft;
            Q_EMIT DefaultLimitNICESoftChanged(d_ptr->DefaultLimitNICESoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitNOFILE"))
    {
        const qulonglong &DefaultLimitNOFILE = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitNOFILE != DefaultLimitNOFILE)
        {
            d_ptr->DefaultLimitNOFILE = DefaultLimitNOFILE;
            Q_EMIT DefaultLimitNOFILEChanged(d_ptr->DefaultLimitNOFILE);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitNOFILESoft"))
    {
        const qulonglong &DefaultLimitNOFILESoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitNOFILESoft != DefaultLimitNOFILESoft)
        {
            d_ptr->DefaultLimitNOFILESoft = DefaultLimitNOFILESoft;
            Q_EMIT DefaultLimitNOFILESoftChanged(d_ptr->DefaultLimitNOFILESoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitNPROC"))
    {
        const qulonglong &DefaultLimitNPROC = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitNPROC != DefaultLimitNPROC)
        {
            d_ptr->DefaultLimitNPROC = DefaultLimitNPROC;
            Q_EMIT DefaultLimitNPROCChanged(d_ptr->DefaultLimitNPROC);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitNPROCSoft"))
    {
        const qulonglong &DefaultLimitNPROCSoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitNPROCSoft != DefaultLimitNPROCSoft)
        {
            d_ptr->DefaultLimitNPROCSoft = DefaultLimitNPROCSoft;
            Q_EMIT DefaultLimitNPROCSoftChanged(d_ptr->DefaultLimitNPROCSoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitRSS"))
    {
        const qulonglong &DefaultLimitRSS = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitRSS != DefaultLimitRSS)
        {
            d_ptr->DefaultLimitRSS = DefaultLimitRSS;
            Q_EMIT DefaultLimitRSSChanged(d_ptr->DefaultLimitRSS);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitRSSSoft"))
    {
        const qulonglong &DefaultLimitRSSSoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitRSSSoft != DefaultLimitRSSSoft)
        {
            d_ptr->DefaultLimitRSSSoft = DefaultLimitRSSSoft;
            Q_EMIT DefaultLimitRSSSoftChanged(d_ptr->DefaultLimitRSSSoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitRTPRIO"))
    {
        const qulonglong &DefaultLimitRTPRIO = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitRTPRIO != DefaultLimitRTPRIO)
        {
            d_ptr->DefaultLimitRTPRIO = DefaultLimitRTPRIO;
            Q_EMIT DefaultLimitRTPRIOChanged(d_ptr->DefaultLimitRTPRIO);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitRTPRIOSoft"))
    {
        const qulonglong &DefaultLimitRTPRIOSoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitRTPRIOSoft != DefaultLimitRTPRIOSoft)
        {
            d_ptr->DefaultLimitRTPRIOSoft = DefaultLimitRTPRIOSoft;
            Q_EMIT DefaultLimitRTPRIOSoftChanged(d_ptr->DefaultLimitRTPRIOSoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitRTTIME"))
    {
        const qulonglong &DefaultLimitRTTIME = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitRTTIME != DefaultLimitRTTIME)
        {
            d_ptr->DefaultLimitRTTIME = DefaultLimitRTTIME;
            Q_EMIT DefaultLimitRTTIMEChanged(d_ptr->DefaultLimitRTTIME);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitRTTIMESoft"))
    {
        const qulonglong &DefaultLimitRTTIMESoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitRTTIMESoft != DefaultLimitRTTIMESoft)
        {
            d_ptr->DefaultLimitRTTIMESoft = DefaultLimitRTTIMESoft;
            Q_EMIT DefaultLimitRTTIMESoftChanged(d_ptr->DefaultLimitRTTIMESoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitSIGPENDING"))
    {
        const qulonglong &DefaultLimitSIGPENDING = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitSIGPENDING != DefaultLimitSIGPENDING)
        {
            d_ptr->DefaultLimitSIGPENDING = DefaultLimitSIGPENDING;
            Q_EMIT DefaultLimitSIGPENDINGChanged(d_ptr->DefaultLimitSIGPENDING);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitSIGPENDINGSoft"))
    {
        const qulonglong &DefaultLimitSIGPENDINGSoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitSIGPENDINGSoft != DefaultLimitSIGPENDINGSoft)
        {
            d_ptr->DefaultLimitSIGPENDINGSoft = DefaultLimitSIGPENDINGSoft;
            Q_EMIT DefaultLimitSIGPENDINGSoftChanged(d_ptr->DefaultLimitSIGPENDINGSoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitSTACK"))
    {
        const qulonglong &DefaultLimitSTACK = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitSTACK != DefaultLimitSTACK)
        {
            d_ptr->DefaultLimitSTACK = DefaultLimitSTACK;
            Q_EMIT DefaultLimitSTACKChanged(d_ptr->DefaultLimitSTACK);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultLimitSTACKSoft"))
    {
        const qulonglong &DefaultLimitSTACKSoft = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultLimitSTACKSoft != DefaultLimitSTACKSoft)
        {
            d_ptr->DefaultLimitSTACKSoft = DefaultLimitSTACKSoft;
            Q_EMIT DefaultLimitSTACKSoftChanged(d_ptr->DefaultLimitSTACKSoft);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultMemoryAccounting"))
    {
        const bool &DefaultMemoryAccounting = qvariant_cast<bool>(value);
        if (d_ptr->DefaultMemoryAccounting != DefaultMemoryAccounting)
        {
            d_ptr->DefaultMemoryAccounting = DefaultMemoryAccounting;
            Q_EMIT DefaultMemoryAccountingChanged(d_ptr->DefaultMemoryAccounting);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultRestartUSec"))
    {
        const qulonglong &DefaultRestartUSec = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultRestartUSec != DefaultRestartUSec)
        {
            d_ptr->DefaultRestartUSec = DefaultRestartUSec;
            Q_EMIT DefaultRestartUSecChanged(d_ptr->DefaultRestartUSec);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultStandardError"))
    {
        const QString &DefaultStandardError = qvariant_cast<QString>(value);
        if (d_ptr->DefaultStandardError != DefaultStandardError)
        {
            d_ptr->DefaultStandardError = DefaultStandardError;
            Q_EMIT DefaultStandardErrorChanged(d_ptr->DefaultStandardError);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultStandardOutput"))
    {
        const QString &DefaultStandardOutput = qvariant_cast<QString>(value);
        if (d_ptr->DefaultStandardOutput != DefaultStandardOutput)
        {
            d_ptr->DefaultStandardOutput = DefaultStandardOutput;
            Q_EMIT DefaultStandardOutputChanged(d_ptr->DefaultStandardOutput);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultStartLimitBurst"))
    {
        const uint &DefaultStartLimitBurst = qvariant_cast<uint>(value);
        if (d_ptr->DefaultStartLimitBurst != DefaultStartLimitBurst)
        {
            d_ptr->DefaultStartLimitBurst = DefaultStartLimitBurst;
            Q_EMIT DefaultStartLimitBurstChanged(d_ptr->DefaultStartLimitBurst);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultStartLimitIntervalUSec"))
    {
        const qulonglong &DefaultStartLimitIntervalUSec = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultStartLimitIntervalUSec != DefaultStartLimitIntervalUSec)
        {
            d_ptr->DefaultStartLimitIntervalUSec = DefaultStartLimitIntervalUSec;
            Q_EMIT DefaultStartLimitIntervalUSecChanged(d_ptr->DefaultStartLimitIntervalUSec);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultTasksAccounting"))
    {
        const bool &DefaultTasksAccounting = qvariant_cast<bool>(value);
        if (d_ptr->DefaultTasksAccounting != DefaultTasksAccounting)
        {
            d_ptr->DefaultTasksAccounting = DefaultTasksAccounting;
            Q_EMIT DefaultTasksAccountingChanged(d_ptr->DefaultTasksAccounting);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultTasksMax"))
    {
        const qulonglong &DefaultTasksMax = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultTasksMax != DefaultTasksMax)
        {
            d_ptr->DefaultTasksMax = DefaultTasksMax;
            Q_EMIT DefaultTasksMaxChanged(d_ptr->DefaultTasksMax);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultTimeoutStartUSec"))
    {
        const qulonglong &DefaultTimeoutStartUSec = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultTimeoutStartUSec != DefaultTimeoutStartUSec)
        {
            d_ptr->DefaultTimeoutStartUSec = DefaultTimeoutStartUSec;
            Q_EMIT DefaultTimeoutStartUSecChanged(d_ptr->DefaultTimeoutStartUSec);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultTimeoutStopUSec"))
    {
        const qulonglong &DefaultTimeoutStopUSec = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultTimeoutStopUSec != DefaultTimeoutStopUSec)
        {
            d_ptr->DefaultTimeoutStopUSec = DefaultTimeoutStopUSec;
            Q_EMIT DefaultTimeoutStopUSecChanged(d_ptr->DefaultTimeoutStopUSec);
        }
        return;
    }

    if (propName == QStringLiteral("DefaultTimerAccuracyUSec"))
    {
        const qulonglong &DefaultTimerAccuracyUSec = qvariant_cast<qulonglong>(value);
        if (d_ptr->DefaultTimerAccuracyUSec != DefaultTimerAccuracyUSec)
        {
            d_ptr->DefaultTimerAccuracyUSec = DefaultTimerAccuracyUSec;
            Q_EMIT DefaultTimerAccuracyUSecChanged(d_ptr->DefaultTimerAccuracyUSec);
        }
        return;
    }

    if (propName == QStringLiteral("Environment"))
    {
        const QStringList &Environment = qvariant_cast<QStringList>(value);
        if (d_ptr->Environment != Environment)
        {
            d_ptr->Environment = Environment;
            Q_EMIT EnvironmentChanged(d_ptr->Environment);
        }
        return;
    }

    if (propName == QStringLiteral("ExitCode"))
    {
        const uchar &ExitCode = qvariant_cast<uchar>(value);
        if (d_ptr->ExitCode != ExitCode)
        {
            d_ptr->ExitCode = ExitCode;
            Q_EMIT ExitCodeChanged(d_ptr->ExitCode);
        }
        return;
    }

    if (propName == QStringLiteral("Features"))
    {
        const QString &Features = qvariant_cast<QString>(value);
        if (d_ptr->Features != Features)
        {
            d_ptr->Features = Features;
            Q_EMIT FeaturesChanged(d_ptr->Features);
        }
        return;
    }

    if (propName == QStringLiteral("FinishTimestamp"))
    {
        const qulonglong &FinishTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->FinishTimestamp != FinishTimestamp)
        {
            d_ptr->FinishTimestamp = FinishTimestamp;
            Q_EMIT FinishTimestampChanged(d_ptr->FinishTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("FinishTimestampMonotonic"))
    {
        const qulonglong &FinishTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->FinishTimestampMonotonic != FinishTimestampMonotonic)
        {
            d_ptr->FinishTimestampMonotonic = FinishTimestampMonotonic;
            Q_EMIT FinishTimestampMonotonicChanged(d_ptr->FinishTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("FirmwareTimestamp"))
    {
        const qulonglong &FirmwareTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->FirmwareTimestamp != FirmwareTimestamp)
        {
            d_ptr->FirmwareTimestamp = FirmwareTimestamp;
            Q_EMIT FirmwareTimestampChanged(d_ptr->FirmwareTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("FirmwareTimestampMonotonic"))
    {
        const qulonglong &FirmwareTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->FirmwareTimestampMonotonic != FirmwareTimestampMonotonic)
        {
            d_ptr->FirmwareTimestampMonotonic = FirmwareTimestampMonotonic;
            Q_EMIT FirmwareTimestampMonotonicChanged(d_ptr->FirmwareTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("GeneratorsFinishTimestamp"))
    {
        const qulonglong &GeneratorsFinishTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->GeneratorsFinishTimestamp != GeneratorsFinishTimestamp)
        {
            d_ptr->GeneratorsFinishTimestamp = GeneratorsFinishTimestamp;
            Q_EMIT GeneratorsFinishTimestampChanged(d_ptr->GeneratorsFinishTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("GeneratorsFinishTimestampMonotonic"))
    {
        const qulonglong &GeneratorsFinishTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->GeneratorsFinishTimestampMonotonic != GeneratorsFinishTimestampMonotonic)
        {
            d_ptr->GeneratorsFinishTimestampMonotonic = GeneratorsFinishTimestampMonotonic;
            Q_EMIT GeneratorsFinishTimestampMonotonicChanged(d_ptr->GeneratorsFinishTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("GeneratorsStartTimestamp"))
    {
        const qulonglong &GeneratorsStartTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->GeneratorsStartTimestamp != GeneratorsStartTimestamp)
        {
            d_ptr->GeneratorsStartTimestamp = GeneratorsStartTimestamp;
            Q_EMIT GeneratorsStartTimestampChanged(d_ptr->GeneratorsStartTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("GeneratorsStartTimestampMonotonic"))
    {
        const qulonglong &GeneratorsStartTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->GeneratorsStartTimestampMonotonic != GeneratorsStartTimestampMonotonic)
        {
            d_ptr->GeneratorsStartTimestampMonotonic = GeneratorsStartTimestampMonotonic;
            Q_EMIT GeneratorsStartTimestampMonotonicChanged(d_ptr->GeneratorsStartTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDGeneratorsFinishTimestamp"))
    {
        const qulonglong &InitRDGeneratorsFinishTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDGeneratorsFinishTimestamp != InitRDGeneratorsFinishTimestamp)
        {
            d_ptr->InitRDGeneratorsFinishTimestamp = InitRDGeneratorsFinishTimestamp;
            Q_EMIT InitRDGeneratorsFinishTimestampChanged(d_ptr->InitRDGeneratorsFinishTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDGeneratorsFinishTimestampMonotonic"))
    {
        const qulonglong &InitRDGeneratorsFinishTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDGeneratorsFinishTimestampMonotonic != InitRDGeneratorsFinishTimestampMonotonic)
        {
            d_ptr->InitRDGeneratorsFinishTimestampMonotonic = InitRDGeneratorsFinishTimestampMonotonic;
            Q_EMIT InitRDGeneratorsFinishTimestampMonotonicChanged(d_ptr->InitRDGeneratorsFinishTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDGeneratorsStartTimestamp"))
    {
        const qulonglong &InitRDGeneratorsStartTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDGeneratorsStartTimestamp != InitRDGeneratorsStartTimestamp)
        {
            d_ptr->InitRDGeneratorsStartTimestamp = InitRDGeneratorsStartTimestamp;
            Q_EMIT InitRDGeneratorsStartTimestampChanged(d_ptr->InitRDGeneratorsStartTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDGeneratorsStartTimestampMonotonic"))
    {
        const qulonglong &InitRDGeneratorsStartTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDGeneratorsStartTimestampMonotonic != InitRDGeneratorsStartTimestampMonotonic)
        {
            d_ptr->InitRDGeneratorsStartTimestampMonotonic = InitRDGeneratorsStartTimestampMonotonic;
            Q_EMIT InitRDGeneratorsStartTimestampMonotonicChanged(d_ptr->InitRDGeneratorsStartTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDSecurityFinishTimestamp"))
    {
        const qulonglong &InitRDSecurityFinishTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDSecurityFinishTimestamp != InitRDSecurityFinishTimestamp)
        {
            d_ptr->InitRDSecurityFinishTimestamp = InitRDSecurityFinishTimestamp;
            Q_EMIT InitRDSecurityFinishTimestampChanged(d_ptr->InitRDSecurityFinishTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDSecurityFinishTimestampMonotonic"))
    {
        const qulonglong &InitRDSecurityFinishTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDSecurityFinishTimestampMonotonic != InitRDSecurityFinishTimestampMonotonic)
        {
            d_ptr->InitRDSecurityFinishTimestampMonotonic = InitRDSecurityFinishTimestampMonotonic;
            Q_EMIT InitRDSecurityFinishTimestampMonotonicChanged(d_ptr->InitRDSecurityFinishTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDSecurityStartTimestamp"))
    {
        const qulonglong &InitRDSecurityStartTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDSecurityStartTimestamp != InitRDSecurityStartTimestamp)
        {
            d_ptr->InitRDSecurityStartTimestamp = InitRDSecurityStartTimestamp;
            Q_EMIT InitRDSecurityStartTimestampChanged(d_ptr->InitRDSecurityStartTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDSecurityStartTimestampMonotonic"))
    {
        const qulonglong &InitRDSecurityStartTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDSecurityStartTimestampMonotonic != InitRDSecurityStartTimestampMonotonic)
        {
            d_ptr->InitRDSecurityStartTimestampMonotonic = InitRDSecurityStartTimestampMonotonic;
            Q_EMIT InitRDSecurityStartTimestampMonotonicChanged(d_ptr->InitRDSecurityStartTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDTimestamp"))
    {
        const qulonglong &InitRDTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDTimestamp != InitRDTimestamp)
        {
            d_ptr->InitRDTimestamp = InitRDTimestamp;
            Q_EMIT InitRDTimestampChanged(d_ptr->InitRDTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDTimestampMonotonic"))
    {
        const qulonglong &InitRDTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDTimestampMonotonic != InitRDTimestampMonotonic)
        {
            d_ptr->InitRDTimestampMonotonic = InitRDTimestampMonotonic;
            Q_EMIT InitRDTimestampMonotonicChanged(d_ptr->InitRDTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDUnitsLoadFinishTimestamp"))
    {
        const qulonglong &InitRDUnitsLoadFinishTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDUnitsLoadFinishTimestamp != InitRDUnitsLoadFinishTimestamp)
        {
            d_ptr->InitRDUnitsLoadFinishTimestamp = InitRDUnitsLoadFinishTimestamp;
            Q_EMIT InitRDUnitsLoadFinishTimestampChanged(d_ptr->InitRDUnitsLoadFinishTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDUnitsLoadFinishTimestampMonotonic"))
    {
        const qulonglong &InitRDUnitsLoadFinishTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDUnitsLoadFinishTimestampMonotonic != InitRDUnitsLoadFinishTimestampMonotonic)
        {
            d_ptr->InitRDUnitsLoadFinishTimestampMonotonic = InitRDUnitsLoadFinishTimestampMonotonic;
            Q_EMIT InitRDUnitsLoadFinishTimestampMonotonicChanged(d_ptr->InitRDUnitsLoadFinishTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDUnitsLoadStartTimestamp"))
    {
        const qulonglong &InitRDUnitsLoadStartTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDUnitsLoadStartTimestamp != InitRDUnitsLoadStartTimestamp)
        {
            d_ptr->InitRDUnitsLoadStartTimestamp = InitRDUnitsLoadStartTimestamp;
            Q_EMIT InitRDUnitsLoadStartTimestampChanged(d_ptr->InitRDUnitsLoadStartTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("InitRDUnitsLoadStartTimestampMonotonic"))
    {
        const qulonglong &InitRDUnitsLoadStartTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->InitRDUnitsLoadStartTimestampMonotonic != InitRDUnitsLoadStartTimestampMonotonic)
        {
            d_ptr->InitRDUnitsLoadStartTimestampMonotonic = InitRDUnitsLoadStartTimestampMonotonic;
            Q_EMIT InitRDUnitsLoadStartTimestampMonotonicChanged(d_ptr->InitRDUnitsLoadStartTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("KernelTimestamp"))
    {
        const qulonglong &KernelTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->KernelTimestamp != KernelTimestamp)
        {
            d_ptr->KernelTimestamp = KernelTimestamp;
            Q_EMIT KernelTimestampChanged(d_ptr->KernelTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("KernelTimestampMonotonic"))
    {
        const qulonglong &KernelTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->KernelTimestampMonotonic != KernelTimestampMonotonic)
        {
            d_ptr->KernelTimestampMonotonic = KernelTimestampMonotonic;
            Q_EMIT KernelTimestampMonotonicChanged(d_ptr->KernelTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("LoaderTimestamp"))
    {
        const qulonglong &LoaderTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->LoaderTimestamp != LoaderTimestamp)
        {
            d_ptr->LoaderTimestamp = LoaderTimestamp;
            Q_EMIT LoaderTimestampChanged(d_ptr->LoaderTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("LoaderTimestampMonotonic"))
    {
        const qulonglong &LoaderTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->LoaderTimestampMonotonic != LoaderTimestampMonotonic)
        {
            d_ptr->LoaderTimestampMonotonic = LoaderTimestampMonotonic;
            Q_EMIT LoaderTimestampMonotonicChanged(d_ptr->LoaderTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("LogLevel"))
    {
        const QString &LogLevel = qvariant_cast<QString>(value);
        if (d_ptr->LogLevel != LogLevel)
        {
            d_ptr->LogLevel = LogLevel;
            Q_EMIT LogLevelChanged(d_ptr->LogLevel);
        }
        return;
    }

    if (propName == QStringLiteral("LogTarget"))
    {
        const QString &LogTarget = qvariant_cast<QString>(value);
        if (d_ptr->LogTarget != LogTarget)
        {
            d_ptr->LogTarget = LogTarget;
            Q_EMIT LogTargetChanged(d_ptr->LogTarget);
        }
        return;
    }

    if (propName == QStringLiteral("NFailedJobs"))
    {
        const uint &NFailedJobs = qvariant_cast<uint>(value);
        if (d_ptr->NFailedJobs != NFailedJobs)
        {
            d_ptr->NFailedJobs = NFailedJobs;
            Q_EMIT NFailedJobsChanged(d_ptr->NFailedJobs);
        }
        return;
    }

    if (propName == QStringLiteral("NFailedUnits"))
    {
        const uint &NFailedUnits = qvariant_cast<uint>(value);
        if (d_ptr->NFailedUnits != NFailedUnits)
        {
            d_ptr->NFailedUnits = NFailedUnits;
            Q_EMIT NFailedUnitsChanged(d_ptr->NFailedUnits);
        }
        return;
    }

    if (propName == QStringLiteral("NInstalledJobs"))
    {
        const uint &NInstalledJobs = qvariant_cast<uint>(value);
        if (d_ptr->NInstalledJobs != NInstalledJobs)
        {
            d_ptr->NInstalledJobs = NInstalledJobs;
            Q_EMIT NInstalledJobsChanged(d_ptr->NInstalledJobs);
        }
        return;
    }

    if (propName == QStringLiteral("NJobs"))
    {
        const uint &NJobs = qvariant_cast<uint>(value);
        if (d_ptr->NJobs != NJobs)
        {
            d_ptr->NJobs = NJobs;
            Q_EMIT NJobsChanged(d_ptr->NJobs);
        }
        return;
    }

    if (propName == QStringLiteral("NNames"))
    {
        const uint &NNames = qvariant_cast<uint>(value);
        if (d_ptr->NNames != NNames)
        {
            d_ptr->NNames = NNames;
            Q_EMIT NNamesChanged(d_ptr->NNames);
        }
        return;
    }

    if (propName == QStringLiteral("Progress"))
    {
        const double &Progress = qvariant_cast<double>(value);
        if (d_ptr->Progress != Progress)
        {
            d_ptr->Progress = Progress;
            Q_EMIT ProgressChanged(d_ptr->Progress);
        }
        return;
    }

    if (propName == QStringLiteral("RuntimeWatchdogUSec"))
    {
        const qulonglong &RuntimeWatchdogUSec = qvariant_cast<qulonglong>(value);
        if (d_ptr->RuntimeWatchdogUSec != RuntimeWatchdogUSec)
        {
            d_ptr->RuntimeWatchdogUSec = RuntimeWatchdogUSec;
            Q_EMIT RuntimeWatchdogUSecChanged(d_ptr->RuntimeWatchdogUSec);
        }
        return;
    }

    if (propName == QStringLiteral("SecurityFinishTimestamp"))
    {
        const qulonglong &SecurityFinishTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->SecurityFinishTimestamp != SecurityFinishTimestamp)
        {
            d_ptr->SecurityFinishTimestamp = SecurityFinishTimestamp;
            Q_EMIT SecurityFinishTimestampChanged(d_ptr->SecurityFinishTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("SecurityFinishTimestampMonotonic"))
    {
        const qulonglong &SecurityFinishTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->SecurityFinishTimestampMonotonic != SecurityFinishTimestampMonotonic)
        {
            d_ptr->SecurityFinishTimestampMonotonic = SecurityFinishTimestampMonotonic;
            Q_EMIT SecurityFinishTimestampMonotonicChanged(d_ptr->SecurityFinishTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("SecurityStartTimestamp"))
    {
        const qulonglong &SecurityStartTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->SecurityStartTimestamp != SecurityStartTimestamp)
        {
            d_ptr->SecurityStartTimestamp = SecurityStartTimestamp;
            Q_EMIT SecurityStartTimestampChanged(d_ptr->SecurityStartTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("SecurityStartTimestampMonotonic"))
    {
        const qulonglong &SecurityStartTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->SecurityStartTimestampMonotonic != SecurityStartTimestampMonotonic)
        {
            d_ptr->SecurityStartTimestampMonotonic = SecurityStartTimestampMonotonic;
            Q_EMIT SecurityStartTimestampMonotonicChanged(d_ptr->SecurityStartTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("ServiceWatchdogs"))
    {
        const bool &ServiceWatchdogs = qvariant_cast<bool>(value);
        if (d_ptr->ServiceWatchdogs != ServiceWatchdogs)
        {
            d_ptr->ServiceWatchdogs = ServiceWatchdogs;
            Q_EMIT ServiceWatchdogsChanged(d_ptr->ServiceWatchdogs);
        }
        return;
    }

    if (propName == QStringLiteral("ShowStatus"))
    {
        const bool &ShowStatus = qvariant_cast<bool>(value);
        if (d_ptr->ShowStatus != ShowStatus)
        {
            d_ptr->ShowStatus = ShowStatus;
            Q_EMIT ShowStatusChanged(d_ptr->ShowStatus);
        }
        return;
    }

    if (propName == QStringLiteral("ShutdownWatchdogUSec"))
    {
        const qulonglong &ShutdownWatchdogUSec = qvariant_cast<qulonglong>(value);
        if (d_ptr->ShutdownWatchdogUSec != ShutdownWatchdogUSec)
        {
            d_ptr->ShutdownWatchdogUSec = ShutdownWatchdogUSec;
            Q_EMIT ShutdownWatchdogUSecChanged(d_ptr->ShutdownWatchdogUSec);
        }
        return;
    }

    if (propName == QStringLiteral("SystemState"))
    {
        const QString &SystemState = qvariant_cast<QString>(value);
        if (d_ptr->SystemState != SystemState)
        {
            d_ptr->SystemState = SystemState;
            Q_EMIT SystemStateChanged(d_ptr->SystemState);
        }
        return;
    }

    if (propName == QStringLiteral("Tainted"))
    {
        const QString &Tainted = qvariant_cast<QString>(value);
        if (d_ptr->Tainted != Tainted)
        {
            d_ptr->Tainted = Tainted;
            Q_EMIT TaintedChanged(d_ptr->Tainted);
        }
        return;
    }

    if (propName == QStringLiteral("TimerSlackNSec"))
    {
        const qulonglong &TimerSlackNSec = qvariant_cast<qulonglong>(value);
        if (d_ptr->TimerSlackNSec != TimerSlackNSec)
        {
            d_ptr->TimerSlackNSec = TimerSlackNSec;
            Q_EMIT TimerSlackNSecChanged(d_ptr->TimerSlackNSec);
        }
        return;
    }

    if (propName == QStringLiteral("UnitPath"))
    {
        const QStringList &UnitPath = qvariant_cast<QStringList>(value);
        if (d_ptr->UnitPath != UnitPath)
        {
            d_ptr->UnitPath = UnitPath;
            Q_EMIT UnitPathChanged(d_ptr->UnitPath);
        }
        return;
    }

    if (propName == QStringLiteral("UnitsLoadFinishTimestamp"))
    {
        const qulonglong &UnitsLoadFinishTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->UnitsLoadFinishTimestamp != UnitsLoadFinishTimestamp)
        {
            d_ptr->UnitsLoadFinishTimestamp = UnitsLoadFinishTimestamp;
            Q_EMIT UnitsLoadFinishTimestampChanged(d_ptr->UnitsLoadFinishTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("UnitsLoadFinishTimestampMonotonic"))
    {
        const qulonglong &UnitsLoadFinishTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->UnitsLoadFinishTimestampMonotonic != UnitsLoadFinishTimestampMonotonic)
        {
            d_ptr->UnitsLoadFinishTimestampMonotonic = UnitsLoadFinishTimestampMonotonic;
            Q_EMIT UnitsLoadFinishTimestampMonotonicChanged(d_ptr->UnitsLoadFinishTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("UnitsLoadStartTimestamp"))
    {
        const qulonglong &UnitsLoadStartTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->UnitsLoadStartTimestamp != UnitsLoadStartTimestamp)
        {
            d_ptr->UnitsLoadStartTimestamp = UnitsLoadStartTimestamp;
            Q_EMIT UnitsLoadStartTimestampChanged(d_ptr->UnitsLoadStartTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("UnitsLoadStartTimestampMonotonic"))
    {
        const qulonglong &UnitsLoadStartTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->UnitsLoadStartTimestampMonotonic != UnitsLoadStartTimestampMonotonic)
        {
            d_ptr->UnitsLoadStartTimestampMonotonic = UnitsLoadStartTimestampMonotonic;
            Q_EMIT UnitsLoadStartTimestampMonotonicChanged(d_ptr->UnitsLoadStartTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("UserspaceTimestamp"))
    {
        const qulonglong &UserspaceTimestamp = qvariant_cast<qulonglong>(value);
        if (d_ptr->UserspaceTimestamp != UserspaceTimestamp)
        {
            d_ptr->UserspaceTimestamp = UserspaceTimestamp;
            Q_EMIT UserspaceTimestampChanged(d_ptr->UserspaceTimestamp);
        }
        return;
    }

    if (propName == QStringLiteral("UserspaceTimestampMonotonic"))
    {
        const qulonglong &UserspaceTimestampMonotonic = qvariant_cast<qulonglong>(value);
        if (d_ptr->UserspaceTimestampMonotonic != UserspaceTimestampMonotonic)
        {
            d_ptr->UserspaceTimestampMonotonic = UserspaceTimestampMonotonic;
            Q_EMIT UserspaceTimestampMonotonicChanged(d_ptr->UserspaceTimestampMonotonic);
        }
        return;
    }

    if (propName == QStringLiteral("Version"))
    {
        const QString &Version = qvariant_cast<QString>(value);
        if (d_ptr->Version != Version)
        {
            d_ptr->Version = Version;
            Q_EMIT VersionChanged(d_ptr->Version);
        }
        return;
    }

    if (propName == QStringLiteral("Virtualization"))
    {
        const QString &Virtualization = qvariant_cast<QString>(value);
        if (d_ptr->Virtualization != Virtualization)
        {
            d_ptr->Virtualization = Virtualization;
            Q_EMIT VirtualizationChanged(d_ptr->Virtualization);
        }
        return;
    }

    qWarning() << "property not handle: " << propName;
    return;
}

QString __Systemd1Manager::architecture()
{
    return qvariant_cast<QString>(internalPropGet("Architecture", &d_ptr->Architecture));
}

bool __Systemd1Manager::confirmSpawn()
{
    return qvariant_cast<bool>(internalPropGet("ConfirmSpawn", &d_ptr->ConfirmSpawn));
}

QString __Systemd1Manager::controlGroup()
{
    return qvariant_cast<QString>(internalPropGet("ControlGroup", &d_ptr->ControlGroup));
}

bool __Systemd1Manager::defaultBlockIOAccounting()
{
    return qvariant_cast<bool>(internalPropGet("DefaultBlockIOAccounting", &d_ptr->DefaultBlockIOAccounting));
}

bool __Systemd1Manager::defaultCPUAccounting()
{
    return qvariant_cast<bool>(internalPropGet("DefaultCPUAccounting", &d_ptr->DefaultCPUAccounting));
}

qulonglong __Systemd1Manager::defaultLimitAS()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitAS", &d_ptr->DefaultLimitAS));
}

qulonglong __Systemd1Manager::defaultLimitASSoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitASSoft", &d_ptr->DefaultLimitASSoft));
}

qulonglong __Systemd1Manager::defaultLimitCORE()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitCORE", &d_ptr->DefaultLimitCORE));
}

qulonglong __Systemd1Manager::defaultLimitCORESoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitCORESoft", &d_ptr->DefaultLimitCORESoft));
}

qulonglong __Systemd1Manager::defaultLimitCPU()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitCPU", &d_ptr->DefaultLimitCPU));
}

qulonglong __Systemd1Manager::defaultLimitCPUSoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitCPUSoft", &d_ptr->DefaultLimitCPUSoft));
}

qulonglong __Systemd1Manager::defaultLimitDATA()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitDATA", &d_ptr->DefaultLimitDATA));
}

qulonglong __Systemd1Manager::defaultLimitDATASoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitDATASoft", &d_ptr->DefaultLimitDATASoft));
}

qulonglong __Systemd1Manager::defaultLimitFSIZE()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitFSIZE", &d_ptr->DefaultLimitFSIZE));
}

qulonglong __Systemd1Manager::defaultLimitFSIZESoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitFSIZESoft", &d_ptr->DefaultLimitFSIZESoft));
}

qulonglong __Systemd1Manager::defaultLimitLOCKS()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitLOCKS", &d_ptr->DefaultLimitLOCKS));
}

qulonglong __Systemd1Manager::defaultLimitLOCKSSoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitLOCKSSoft", &d_ptr->DefaultLimitLOCKSSoft));
}

qulonglong __Systemd1Manager::defaultLimitMEMLOCK()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitMEMLOCK", &d_ptr->DefaultLimitMEMLOCK));
}

qulonglong __Systemd1Manager::defaultLimitMEMLOCKSoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitMEMLOCKSoft", &d_ptr->DefaultLimitMEMLOCKSoft));
}

qulonglong __Systemd1Manager::defaultLimitMSGQUEUE()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitMSGQUEUE", &d_ptr->DefaultLimitMSGQUEUE));
}

qulonglong __Systemd1Manager::defaultLimitMSGQUEUESoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitMSGQUEUESoft", &d_ptr->DefaultLimitMSGQUEUESoft));
}

qulonglong __Systemd1Manager::defaultLimitNICE()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitNICE", &d_ptr->DefaultLimitNICE));
}

qulonglong __Systemd1Manager::defaultLimitNICESoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitNICESoft", &d_ptr->DefaultLimitNICESoft));
}

qulonglong __Systemd1Manager::defaultLimitNOFILE()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitNOFILE", &d_ptr->DefaultLimitNOFILE));
}

qulonglong __Systemd1Manager::defaultLimitNOFILESoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitNOFILESoft", &d_ptr->DefaultLimitNOFILESoft));
}

qulonglong __Systemd1Manager::defaultLimitNPROC()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitNPROC", &d_ptr->DefaultLimitNPROC));
}

qulonglong __Systemd1Manager::defaultLimitNPROCSoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitNPROCSoft", &d_ptr->DefaultLimitNPROCSoft));
}

qulonglong __Systemd1Manager::defaultLimitRSS()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitRSS", &d_ptr->DefaultLimitRSS));
}

qulonglong __Systemd1Manager::defaultLimitRSSSoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitRSSSoft", &d_ptr->DefaultLimitRSSSoft));
}

qulonglong __Systemd1Manager::defaultLimitRTPRIO()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitRTPRIO", &d_ptr->DefaultLimitRTPRIO));
}

qulonglong __Systemd1Manager::defaultLimitRTPRIOSoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitRTPRIOSoft", &d_ptr->DefaultLimitRTPRIOSoft));
}

qulonglong __Systemd1Manager::defaultLimitRTTIME()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitRTTIME", &d_ptr->DefaultLimitRTTIME));
}

qulonglong __Systemd1Manager::defaultLimitRTTIMESoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitRTTIMESoft", &d_ptr->DefaultLimitRTTIMESoft));
}

qulonglong __Systemd1Manager::defaultLimitSIGPENDING()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitSIGPENDING", &d_ptr->DefaultLimitSIGPENDING));
}

qulonglong __Systemd1Manager::defaultLimitSIGPENDINGSoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitSIGPENDINGSoft", &d_ptr->DefaultLimitSIGPENDINGSoft));
}

qulonglong __Systemd1Manager::defaultLimitSTACK()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitSTACK", &d_ptr->DefaultLimitSTACK));
}

qulonglong __Systemd1Manager::defaultLimitSTACKSoft()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultLimitSTACKSoft", &d_ptr->DefaultLimitSTACKSoft));
}

bool __Systemd1Manager::defaultMemoryAccounting()
{
    return qvariant_cast<bool>(internalPropGet("DefaultMemoryAccounting", &d_ptr->DefaultMemoryAccounting));
}

qulonglong __Systemd1Manager::defaultRestartUSec()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultRestartUSec", &d_ptr->DefaultRestartUSec));
}

QString __Systemd1Manager::defaultStandardError()
{
    return qvariant_cast<QString>(internalPropGet("DefaultStandardError", &d_ptr->DefaultStandardError));
}

QString __Systemd1Manager::defaultStandardOutput()
{
    return qvariant_cast<QString>(internalPropGet("DefaultStandardOutput", &d_ptr->DefaultStandardOutput));
}

uint __Systemd1Manager::defaultStartLimitBurst()
{
    return qvariant_cast<uint>(internalPropGet("DefaultStartLimitBurst", &d_ptr->DefaultStartLimitBurst));
}

qulonglong __Systemd1Manager::defaultStartLimitIntervalUSec()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultStartLimitIntervalUSec", &d_ptr->DefaultStartLimitIntervalUSec));
}

bool __Systemd1Manager::defaultTasksAccounting()
{
    return qvariant_cast<bool>(internalPropGet("DefaultTasksAccounting", &d_ptr->DefaultTasksAccounting));
}

qulonglong __Systemd1Manager::defaultTasksMax()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultTasksMax", &d_ptr->DefaultTasksMax));
}

qulonglong __Systemd1Manager::defaultTimeoutStartUSec()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultTimeoutStartUSec", &d_ptr->DefaultTimeoutStartUSec));
}

qulonglong __Systemd1Manager::defaultTimeoutStopUSec()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultTimeoutStopUSec", &d_ptr->DefaultTimeoutStopUSec));
}

qulonglong __Systemd1Manager::defaultTimerAccuracyUSec()
{
    return qvariant_cast<qulonglong>(internalPropGet("DefaultTimerAccuracyUSec", &d_ptr->DefaultTimerAccuracyUSec));
}

QStringList __Systemd1Manager::environment()
{
    return qvariant_cast<QStringList>(internalPropGet("Environment", &d_ptr->Environment));
}

uchar __Systemd1Manager::exitCode()
{
    return qvariant_cast<uchar>(internalPropGet("ExitCode", &d_ptr->ExitCode));
}

QString __Systemd1Manager::features()
{
    return qvariant_cast<QString>(internalPropGet("Features", &d_ptr->Features));
}

qulonglong __Systemd1Manager::finishTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("FinishTimestamp", &d_ptr->FinishTimestamp));
}

qulonglong __Systemd1Manager::finishTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("FinishTimestampMonotonic", &d_ptr->FinishTimestampMonotonic));
}

qulonglong __Systemd1Manager::firmwareTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("FirmwareTimestamp", &d_ptr->FirmwareTimestamp));
}

qulonglong __Systemd1Manager::firmwareTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("FirmwareTimestampMonotonic", &d_ptr->FirmwareTimestampMonotonic));
}

qulonglong __Systemd1Manager::generatorsFinishTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("GeneratorsFinishTimestamp", &d_ptr->GeneratorsFinishTimestamp));
}

qulonglong __Systemd1Manager::generatorsFinishTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("GeneratorsFinishTimestampMonotonic", &d_ptr->GeneratorsFinishTimestampMonotonic));
}

qulonglong __Systemd1Manager::generatorsStartTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("GeneratorsStartTimestamp", &d_ptr->GeneratorsStartTimestamp));
}

qulonglong __Systemd1Manager::generatorsStartTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("GeneratorsStartTimestampMonotonic", &d_ptr->GeneratorsStartTimestampMonotonic));
}

qulonglong __Systemd1Manager::initRDGeneratorsFinishTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDGeneratorsFinishTimestamp", &d_ptr->InitRDGeneratorsFinishTimestamp));
}

qulonglong __Systemd1Manager::initRDGeneratorsFinishTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDGeneratorsFinishTimestampMonotonic", &d_ptr->InitRDGeneratorsFinishTimestampMonotonic));
}

qulonglong __Systemd1Manager::initRDGeneratorsStartTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDGeneratorsStartTimestamp", &d_ptr->InitRDGeneratorsStartTimestamp));
}

qulonglong __Systemd1Manager::initRDGeneratorsStartTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDGeneratorsStartTimestampMonotonic", &d_ptr->InitRDGeneratorsStartTimestampMonotonic));
}

qulonglong __Systemd1Manager::initRDSecurityFinishTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDSecurityFinishTimestamp", &d_ptr->InitRDSecurityFinishTimestamp));
}

qulonglong __Systemd1Manager::initRDSecurityFinishTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDSecurityFinishTimestampMonotonic", &d_ptr->InitRDSecurityFinishTimestampMonotonic));
}

qulonglong __Systemd1Manager::initRDSecurityStartTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDSecurityStartTimestamp", &d_ptr->InitRDSecurityStartTimestamp));
}

qulonglong __Systemd1Manager::initRDSecurityStartTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDSecurityStartTimestampMonotonic", &d_ptr->InitRDSecurityStartTimestampMonotonic));
}

qulonglong __Systemd1Manager::initRDTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDTimestamp", &d_ptr->InitRDTimestamp));
}

qulonglong __Systemd1Manager::initRDTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDTimestampMonotonic", &d_ptr->InitRDTimestampMonotonic));
}

qulonglong __Systemd1Manager::initRDUnitsLoadFinishTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDUnitsLoadFinishTimestamp", &d_ptr->InitRDUnitsLoadFinishTimestamp));
}

qulonglong __Systemd1Manager::initRDUnitsLoadFinishTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDUnitsLoadFinishTimestampMonotonic", &d_ptr->InitRDUnitsLoadFinishTimestampMonotonic));
}

qulonglong __Systemd1Manager::initRDUnitsLoadStartTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDUnitsLoadStartTimestamp", &d_ptr->InitRDUnitsLoadStartTimestamp));
}

qulonglong __Systemd1Manager::initRDUnitsLoadStartTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("InitRDUnitsLoadStartTimestampMonotonic", &d_ptr->InitRDUnitsLoadStartTimestampMonotonic));
}

qulonglong __Systemd1Manager::kernelTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("KernelTimestamp", &d_ptr->KernelTimestamp));
}

qulonglong __Systemd1Manager::kernelTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("KernelTimestampMonotonic", &d_ptr->KernelTimestampMonotonic));
}

qulonglong __Systemd1Manager::loaderTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("LoaderTimestamp", &d_ptr->LoaderTimestamp));
}

qulonglong __Systemd1Manager::loaderTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("LoaderTimestampMonotonic", &d_ptr->LoaderTimestampMonotonic));
}

QString __Systemd1Manager::logLevel()
{
    return qvariant_cast<QString>(internalPropGet("LogLevel", &d_ptr->LogLevel));
}

void __Systemd1Manager::setLogLevel(const QString &value)
{

   internalPropSet("LogLevel", QVariant::fromValue(value), &d_ptr->LogLevel);
}

QString __Systemd1Manager::logTarget()
{
    return qvariant_cast<QString>(internalPropGet("LogTarget", &d_ptr->LogTarget));
}

void __Systemd1Manager::setLogTarget(const QString &value)
{

   internalPropSet("LogTarget", QVariant::fromValue(value), &d_ptr->LogTarget);
}

uint __Systemd1Manager::nFailedJobs()
{
    return qvariant_cast<uint>(internalPropGet("NFailedJobs", &d_ptr->NFailedJobs));
}

uint __Systemd1Manager::nFailedUnits()
{
    return qvariant_cast<uint>(internalPropGet("NFailedUnits", &d_ptr->NFailedUnits));
}

uint __Systemd1Manager::nInstalledJobs()
{
    return qvariant_cast<uint>(internalPropGet("NInstalledJobs", &d_ptr->NInstalledJobs));
}

uint __Systemd1Manager::nJobs()
{
    return qvariant_cast<uint>(internalPropGet("NJobs", &d_ptr->NJobs));
}

uint __Systemd1Manager::nNames()
{
    return qvariant_cast<uint>(internalPropGet("NNames", &d_ptr->NNames));
}

double __Systemd1Manager::progress()
{
    return qvariant_cast<double>(internalPropGet("Progress", &d_ptr->Progress));
}

qulonglong __Systemd1Manager::runtimeWatchdogUSec()
{
    return qvariant_cast<qulonglong>(internalPropGet("RuntimeWatchdogUSec", &d_ptr->RuntimeWatchdogUSec));
}

void __Systemd1Manager::setRuntimeWatchdogUSec(qulonglong value)
{

   internalPropSet("RuntimeWatchdogUSec", QVariant::fromValue(value), &d_ptr->RuntimeWatchdogUSec);
}

qulonglong __Systemd1Manager::securityFinishTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("SecurityFinishTimestamp", &d_ptr->SecurityFinishTimestamp));
}

qulonglong __Systemd1Manager::securityFinishTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("SecurityFinishTimestampMonotonic", &d_ptr->SecurityFinishTimestampMonotonic));
}

qulonglong __Systemd1Manager::securityStartTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("SecurityStartTimestamp", &d_ptr->SecurityStartTimestamp));
}

qulonglong __Systemd1Manager::securityStartTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("SecurityStartTimestampMonotonic", &d_ptr->SecurityStartTimestampMonotonic));
}

bool __Systemd1Manager::serviceWatchdogs()
{
    return qvariant_cast<bool>(internalPropGet("ServiceWatchdogs", &d_ptr->ServiceWatchdogs));
}

void __Systemd1Manager::setServiceWatchdogs(bool value)
{

   internalPropSet("ServiceWatchdogs", QVariant::fromValue(value), &d_ptr->ServiceWatchdogs);
}

bool __Systemd1Manager::showStatus()
{
    return qvariant_cast<bool>(internalPropGet("ShowStatus", &d_ptr->ShowStatus));
}

qulonglong __Systemd1Manager::shutdownWatchdogUSec()
{
    return qvariant_cast<qulonglong>(internalPropGet("ShutdownWatchdogUSec", &d_ptr->ShutdownWatchdogUSec));
}

void __Systemd1Manager::setShutdownWatchdogUSec(qulonglong value)
{

   internalPropSet("ShutdownWatchdogUSec", QVariant::fromValue(value), &d_ptr->ShutdownWatchdogUSec);
}

QString __Systemd1Manager::systemState()
{
    return qvariant_cast<QString>(internalPropGet("SystemState", &d_ptr->SystemState));
}

QString __Systemd1Manager::tainted()
{
    return qvariant_cast<QString>(internalPropGet("Tainted", &d_ptr->Tainted));
}

qulonglong __Systemd1Manager::timerSlackNSec()
{
    return qvariant_cast<qulonglong>(internalPropGet("TimerSlackNSec", &d_ptr->TimerSlackNSec));
}

QStringList __Systemd1Manager::unitPath()
{
    return qvariant_cast<QStringList>(internalPropGet("UnitPath", &d_ptr->UnitPath));
}

qulonglong __Systemd1Manager::unitsLoadFinishTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("UnitsLoadFinishTimestamp", &d_ptr->UnitsLoadFinishTimestamp));
}

qulonglong __Systemd1Manager::unitsLoadFinishTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("UnitsLoadFinishTimestampMonotonic", &d_ptr->UnitsLoadFinishTimestampMonotonic));
}

qulonglong __Systemd1Manager::unitsLoadStartTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("UnitsLoadStartTimestamp", &d_ptr->UnitsLoadStartTimestamp));
}

qulonglong __Systemd1Manager::unitsLoadStartTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("UnitsLoadStartTimestampMonotonic", &d_ptr->UnitsLoadStartTimestampMonotonic));
}

qulonglong __Systemd1Manager::userspaceTimestamp()
{
    return qvariant_cast<qulonglong>(internalPropGet("UserspaceTimestamp", &d_ptr->UserspaceTimestamp));
}

qulonglong __Systemd1Manager::userspaceTimestampMonotonic()
{
    return qvariant_cast<qulonglong>(internalPropGet("UserspaceTimestampMonotonic", &d_ptr->UserspaceTimestampMonotonic));
}

QString __Systemd1Manager::version()
{
    return qvariant_cast<QString>(internalPropGet("Version", &d_ptr->Version));
}

QString __Systemd1Manager::virtualization()
{
    return qvariant_cast<QString>(internalPropGet("Virtualization", &d_ptr->Virtualization));
}

void __Systemd1Manager::CallQueued(const QString &callName, const QList<QVariant> &args)
{
    if (d_ptr->m_waittingCalls.contains(callName))
    {
        d_ptr->m_waittingCalls[callName] = args;
        return;
    }
    if (d_ptr->m_processingCalls.contains(callName))
    {
        d_ptr->m_waittingCalls.insert(callName, args);
    } else {
        QDBusPendingCallWatcher *watcher = new QDBusPendingCallWatcher(asyncCallWithArgumentList(callName, args));
        connect(watcher, &QDBusPendingCallWatcher::finished, this, &__Systemd1Manager::onPendingCallFinished);
        d_ptr->m_processingCalls.insert(callName, watcher);
    }
}

void __Systemd1Manager::onPendingCallFinished(QDBusPendingCallWatcher *w)
{
    w->deleteLater();
    const auto callName = d_ptr->m_processingCalls.key(w);
    Q_ASSERT(!callName.isEmpty());
    if (callName.isEmpty())
        return;
    d_ptr->m_processingCalls.remove(callName);
    if (!d_ptr->m_waittingCalls.contains(callName))
        return;
    const auto args = d_ptr->m_waittingCalls.take(callName);
    CallQueued(callName, args);
}
