/*
 * This file was generated by qdbusxml2cpp version 0.8
 * Command line was: qdbusxml2cpp -m -i syncthingservice.h -p managerinterface /build/syncthingtray/src/syncthingtray-2.0.10/syncthingconnector/org.freedesktop.systemd1.Manager.xml
 *
 * qdbusxml2cpp is Copyright (C) 2023 The Qt Company Ltd.
 *
 * This is an auto-generated file.
 * Do not edit! All changes made to it will be lost.
 */

#ifndef MANAGERINTERFACE_H
#define MANAGERINTERFACE_H

#include <QtCore/QObject>
#include <QtCore/QByteArray>
#include <QtCore/QList>
#include <QtCore/QMap>
#include <QtCore/QString>
#include <QtCore/QStringList>
#include <QtCore/QVariant>
#include <QtDBus/QtDBus>
#include "syncthingservice.h"

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

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

    ~OrgFreedesktopSystemd1ManagerInterface();

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Q_PROPERTY(uchar ExitCode READ exitCode)
    inline uchar exitCode() const
    { return qvariant_cast< uchar >(property("ExitCode")); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Q_PROPERTY(QString LogLevel READ logLevel WRITE setLogLevel)
    inline QString logLevel() const
    { return qvariant_cast< QString >(property("LogLevel")); }
    inline void setLogLevel(const QString &value)
    { setProperty("LogLevel", QVariant::fromValue(value)); }

    Q_PROPERTY(QString LogTarget READ logTarget WRITE setLogTarget)
    inline QString logTarget() const
    { return qvariant_cast< QString >(property("LogTarget")); }
    inline void setLogTarget(const QString &value)
    { setProperty("LogTarget", QVariant::fromValue(value)); }

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

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

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

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

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

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

    Q_PROPERTY(qulonglong RuntimeWatchdogUSec READ runtimeWatchdogUSec WRITE setRuntimeWatchdogUSec)
    inline qulonglong runtimeWatchdogUSec() const
    { return qvariant_cast< qulonglong >(property("RuntimeWatchdogUSec")); }
    inline void setRuntimeWatchdogUSec(qulonglong value)
    { setProperty("RuntimeWatchdogUSec", QVariant::fromValue(value)); }

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

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

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

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

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

    Q_PROPERTY(qulonglong ShutdownWatchdogUSec READ shutdownWatchdogUSec WRITE setShutdownWatchdogUSec)
    inline qulonglong shutdownWatchdogUSec() const
    { return qvariant_cast< qulonglong >(property("ShutdownWatchdogUSec")); }
    inline void setShutdownWatchdogUSec(qulonglong value)
    { setProperty("ShutdownWatchdogUSec", QVariant::fromValue(value)); }

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

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

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

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

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

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

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

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

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

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

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

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

public Q_SLOTS: // METHODS
    inline QDBusPendingReply<> CancelJob(uint in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);
        return asyncCallWithArgumentList(QStringLiteral("CancelJob"), argumentList);
    }

    inline QDBusPendingReply<> ClearJobs()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("ClearJobs"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> CreateSnapshot(const QString &in0, bool in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("CreateSnapshot"), argumentList);
    }

    inline QDBusPendingReply<Data::ManagerDBusUnitFileChangeList> DisableUnitFiles(const QStringList &in0, bool in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("DisableUnitFiles"), argumentList);
    }

    inline QDBusPendingReply<QString> Dump()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("Dump"), argumentList);
    }

    inline QDBusPendingReply<bool, Data::ManagerDBusUnitFileChangeList> EnableUnitFiles(const QStringList &in0, bool in1, bool in2)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2);
        return asyncCallWithArgumentList(QStringLiteral("EnableUnitFiles"), argumentList);
    }
    inline QDBusReply<bool> EnableUnitFiles(const QStringList &in0, bool in1, bool in2, Data::ManagerDBusUnitFileChangeList &out1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2);
        QDBusMessage reply = callWithArgumentList(QDBus::Block, QStringLiteral("EnableUnitFiles"), argumentList);
        if (reply.type() == QDBusMessage::ReplyMessage && reply.arguments().count() == 2) {
            out1 = qdbus_cast<Data::ManagerDBusUnitFileChangeList>(reply.arguments().at(1));
        }
        return reply;
    }

    inline QDBusPendingReply<> Exit()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("Exit"), argumentList);
    }

    inline QDBusPendingReply<QString> GetDefaultTarget()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("GetDefaultTarget"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> GetJob(uint in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);
        return asyncCallWithArgumentList(QStringLiteral("GetJob"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> GetUnit(const QString &in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);
        return asyncCallWithArgumentList(QStringLiteral("GetUnit"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> GetUnitByInvocationID(const QByteArray &in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);
        return asyncCallWithArgumentList(QStringLiteral("GetUnitByInvocationID"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> GetUnitByPID(uint in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);
        return asyncCallWithArgumentList(QStringLiteral("GetUnitByPID"), argumentList);
    }

    inline QDBusPendingReply<QStringList> GetUnitFileLinks(const QString &in0, bool in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("GetUnitFileLinks"), argumentList);
    }

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

    inline QDBusPendingReply<> Halt()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("Halt"), argumentList);
    }

    inline QDBusPendingReply<> KExec()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("KExec"), argumentList);
    }

    inline QDBusPendingReply<> KillUnit(const QString &in0, const QString &in1, int in2)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2);
        return asyncCallWithArgumentList(QStringLiteral("KillUnit"), argumentList);
    }

    inline QDBusPendingReply<Data::ManagerDBusUnitFileChangeList> LinkUnitFiles(const QStringList &in0, bool in1, bool in2)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2);
        return asyncCallWithArgumentList(QStringLiteral("LinkUnitFiles"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> LoadUnit(const QString &in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);
        return asyncCallWithArgumentList(QStringLiteral("LoadUnit"), argumentList);
    }

    inline QDBusPendingReply<uint> LookupDynamicUserByName(const QString &in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);
        return asyncCallWithArgumentList(QStringLiteral("LookupDynamicUserByName"), argumentList);
    }

    inline QDBusPendingReply<QString> LookupDynamicUserByUID(uint in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);
        return asyncCallWithArgumentList(QStringLiteral("LookupDynamicUserByUID"), argumentList);
    }

    inline QDBusPendingReply<Data::ManagerDBusUnitFileChangeList> MaskUnitFiles(const QStringList &in0, bool in1, bool in2)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2);
        return asyncCallWithArgumentList(QStringLiteral("MaskUnitFiles"), argumentList);
    }

    inline QDBusPendingReply<> PowerOff()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("PowerOff"), argumentList);
    }

    inline QDBusPendingReply<bool, Data::ManagerDBusUnitFileChangeList> PresetUnitFiles(const QStringList &in0, bool in1, bool in2)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2);
        return asyncCallWithArgumentList(QStringLiteral("PresetUnitFiles"), argumentList);
    }
    inline QDBusReply<bool> PresetUnitFiles(const QStringList &in0, bool in1, bool in2, Data::ManagerDBusUnitFileChangeList &out1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2);
        QDBusMessage reply = callWithArgumentList(QDBus::Block, QStringLiteral("PresetUnitFiles"), argumentList);
        if (reply.type() == QDBusMessage::ReplyMessage && reply.arguments().count() == 2) {
            out1 = qdbus_cast<Data::ManagerDBusUnitFileChangeList>(reply.arguments().at(1));
        }
        return reply;
    }

    inline QDBusPendingReply<bool, Data::ManagerDBusUnitFileChangeList> PresetUnitFilesWithMode(const QStringList &in0, const QString &in1, bool in2, bool in3)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2) << QVariant::fromValue(in3);
        return asyncCallWithArgumentList(QStringLiteral("PresetUnitFilesWithMode"), argumentList);
    }
    inline QDBusReply<bool> PresetUnitFilesWithMode(const QStringList &in0, const QString &in1, bool in2, bool in3, Data::ManagerDBusUnitFileChangeList &out1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2) << QVariant::fromValue(in3);
        QDBusMessage reply = callWithArgumentList(QDBus::Block, QStringLiteral("PresetUnitFilesWithMode"), argumentList);
        if (reply.type() == QDBusMessage::ReplyMessage && reply.arguments().count() == 2) {
            out1 = qdbus_cast<Data::ManagerDBusUnitFileChangeList>(reply.arguments().at(1));
        }
        return reply;
    }

    inline QDBusPendingReply<> Reboot()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("Reboot"), argumentList);
    }

    inline QDBusPendingReply<bool, Data::ManagerDBusUnitFileChangeList> ReenableUnitFiles(const QStringList &in0, bool in1, bool in2)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2);
        return asyncCallWithArgumentList(QStringLiteral("ReenableUnitFiles"), argumentList);
    }
    inline QDBusReply<bool> ReenableUnitFiles(const QStringList &in0, bool in1, bool in2, Data::ManagerDBusUnitFileChangeList &out1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2);
        QDBusMessage reply = callWithArgumentList(QDBus::Block, QStringLiteral("ReenableUnitFiles"), argumentList);
        if (reply.type() == QDBusMessage::ReplyMessage && reply.arguments().count() == 2) {
            out1 = qdbus_cast<Data::ManagerDBusUnitFileChangeList>(reply.arguments().at(1));
        }
        return reply;
    }

    inline QDBusPendingReply<> Reexecute()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("Reexecute"), argumentList);
    }

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

    inline QDBusPendingReply<> Reload()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("Reload"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> ReloadOrRestartUnit(const QString &in0, const QString &in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("ReloadOrRestartUnit"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> ReloadOrTryRestartUnit(const QString &in0, const QString &in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("ReloadOrTryRestartUnit"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> ReloadUnit(const QString &in0, const QString &in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("ReloadUnit"), argumentList);
    }

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

    inline QDBusPendingReply<> ResetFailed()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("ResetFailed"), argumentList);
    }

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

    inline QDBusPendingReply<QDBusObjectPath> RestartUnit(const QString &in0, const QString &in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("RestartUnit"), argumentList);
    }

    inline QDBusPendingReply<Data::ManagerDBusUnitFileChangeList> RevertUnitFiles(const QStringList &in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);
        return asyncCallWithArgumentList(QStringLiteral("RevertUnitFiles"), argumentList);
    }

    inline QDBusPendingReply<Data::ManagerDBusUnitFileChangeList> SetDefaultTarget(const QString &in0, bool in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("SetDefaultTarget"), argumentList);
    }

    inline QDBusPendingReply<> SetEnvironment(const QStringList &in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);
        return asyncCallWithArgumentList(QStringLiteral("SetEnvironment"), argumentList);
    }

    inline QDBusPendingReply<> SetExitCode(uchar in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);
        return asyncCallWithArgumentList(QStringLiteral("SetExitCode"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> StartUnit(const QString &in0, const QString &in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("StartUnit"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> StartUnitReplace(const QString &in0, const QString &in1, const QString &in2)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1) << QVariant::fromValue(in2);
        return asyncCallWithArgumentList(QStringLiteral("StartUnitReplace"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> StopUnit(const QString &in0, const QString &in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("StopUnit"), argumentList);
    }

    inline QDBusPendingReply<> Subscribe()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("Subscribe"), argumentList);
    }

    inline QDBusPendingReply<> SwitchRoot(const QString &in0, const QString &in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("SwitchRoot"), argumentList);
    }

    inline QDBusPendingReply<QDBusObjectPath> TryRestartUnit(const QString &in0, const QString &in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("TryRestartUnit"), argumentList);
    }

    inline QDBusPendingReply<Data::ManagerDBusUnitFileChangeList> UnmaskUnitFiles(const QStringList &in0, bool in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("UnmaskUnitFiles"), argumentList);
    }

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

    inline QDBusPendingReply<> UnsetAndSetEnvironment(const QStringList &in0, const QStringList &in1)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0) << QVariant::fromValue(in1);
        return asyncCallWithArgumentList(QStringLiteral("UnsetAndSetEnvironment"), argumentList);
    }

    inline QDBusPendingReply<> UnsetEnvironment(const QStringList &in0)
    {
        QList<QVariant> argumentList;
        argumentList << QVariant::fromValue(in0);
        return asyncCallWithArgumentList(QStringLiteral("UnsetEnvironment"), argumentList);
    }

    inline QDBusPendingReply<> Unsubscribe()
    {
        QList<QVariant> argumentList;
        return asyncCallWithArgumentList(QStringLiteral("Unsubscribe"), argumentList);
    }

Q_SIGNALS: // SIGNALS
    void JobNew(uint in0, const QDBusObjectPath &in1, const QString &in2);
    void JobRemoved(uint in0, const QDBusObjectPath &in1, const QString &in2, const QString &in3);
    void Reloading(bool in0);
    void StartupFinished(qulonglong in0, qulonglong in1, qulonglong in2, qulonglong in3, qulonglong in4, qulonglong in5);
    void UnitFilesChanged();
    void UnitNew(const QString &in0, const QDBusObjectPath &in1);
    void UnitRemoved(const QString &in0, const QDBusObjectPath &in1);
};

namespace org {
  namespace freedesktop {
    namespace systemd1 {
      typedef ::OrgFreedesktopSystemd1ManagerInterface Manager;
    }
  }
}
#endif
