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

#include "../../../include/login/dloginmanager.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


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

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto Dtk::Login::DLoginManager::qt_create_metaobjectdata<qt_meta_tag_ZN3Dtk5Login13DLoginManagerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Dtk::Login::DLoginManager",
        "prepareForShutdown",
        "",
        "value",
        "prepareForSleep",
        "seatNew",
        "seatId",
        "seatRemoved",
        "sessionNew",
        "sessionId",
        "sessionRemoved",
        "userNew",
        "UID",
        "userRemoved",
        "activateSession",
        "DExpected<void>",
        "activateSessionOnSeat",
        "canHalt",
        "DExpected<LoginExecStatus>",
        "canHibernate",
        "canHybridSleep",
        "canPowerOff",
        "canReboot",
        "canSuspend",
        "canSuspendThenHibernate",
        "cancelScheduledShutdown",
        "DExpected<bool>",
        "findSeatById",
        "DExpected<LoginSeatPtr>",
        "findSessionById",
        "DExpected<LoginSessionPtr>",
        "findSessionByPID",
        "PID",
        "findUserById",
        "DExpected<LoginUserPtr>",
        "findUserByPID",
        "halt",
        "interactive",
        "hibernate",
        "hybridSleep",
        "inhibit",
        "DExpected<int>",
        "what",
        "who",
        "why",
        "LoginInhibitMode",
        "mode",
        "killSession",
        "LoginSessionRole",
        "signalNumber",
        "killUser",
        "listInhibitors",
        "DExpected<LoginInhibitorList>",
        "listSeats",
        "DExpected<QStringList>",
        "listSessions",
        "listUsers",
        "DExpected<QList<quint32>>",
        "lockSession",
        "powerOff",
        "reboot",
        "scheduleShutdown",
        "LoginShutdownType",
        "type",
        "usec",
        "setUserLinger",
        "enable",
        "suspend",
        "suspendThenHibernate",
        "terminateSession",
        "terminateUser",
        "uid",
        "logout",
        "currentSeat",
        "currentSession",
        "currentUser",
        "killExcludeUsers",
        "killOnlyUsers",
        "docked",
        "idleHint",
        "killUserProcesses",
        "lidClosed",
        "preparingForShutdown",
        "preparingForSleep",
        "removeIPC",
        "blockInhibited",
        "delayInhibited",
        "handleHibernateKey",
        "PowerAction",
        "handleLidSwitch",
        "handleLidSwitchDocked",
        "handleLidSwitchExternalPower",
        "handlePowerKey",
        "handleSuspendKey",
        "idleAction",
        "scheduledShutdown",
        "ScheduledShutdownValue",
        "nAutoVTs",
        "holdoffTimeoutUSec",
        "idleActionUSec",
        "idleSinceHint",
        "idleSinceHintMonotonic",
        "inhibitDelayMaxUSec",
        "inhibitorsMax",
        "nCurrentInhibitors",
        "nCurrentSessions",
        "runtimeDirectoryInodesMax",
        "runtimeDirectorySize",
        "sessionsMax",
        "userStopDelayUSec"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'prepareForShutdown'
        QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'prepareForSleep'
        QtMocHelpers::SignalData<void(bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'seatNew'
        QtMocHelpers::SignalData<void(const QString &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 6 },
        }}),
        // Signal 'seatRemoved'
        QtMocHelpers::SignalData<void(const QString &)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 6 },
        }}),
        // Signal 'sessionNew'
        QtMocHelpers::SignalData<void(const QString &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 9 },
        }}),
        // Signal 'sessionRemoved'
        QtMocHelpers::SignalData<void(const QString &)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 9 },
        }}),
        // Signal 'userNew'
        QtMocHelpers::SignalData<void(quint32)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 12 },
        }}),
        // Signal 'userRemoved'
        QtMocHelpers::SignalData<void(quint32)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 12 },
        }}),
        // Slot 'activateSession'
        QtMocHelpers::SlotData<DExpected<void>(const QString &)>(14, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::QString, 9 },
        }}),
        // Slot 'activateSessionOnSeat'
        QtMocHelpers::SlotData<DExpected<void>(const QString &, const QString &)>(16, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::QString, 9 }, { QMetaType::QString, 6 },
        }}),
        // Slot 'canHalt'
        QtMocHelpers::SlotData<DExpected<LoginExecStatus>()>(17, 2, QMC::AccessPublic, 0x80000000 | 18),
        // Slot 'canHibernate'
        QtMocHelpers::SlotData<DExpected<LoginExecStatus>()>(19, 2, QMC::AccessPublic, 0x80000000 | 18),
        // Slot 'canHybridSleep'
        QtMocHelpers::SlotData<DExpected<LoginExecStatus>()>(20, 2, QMC::AccessPublic, 0x80000000 | 18),
        // Slot 'canPowerOff'
        QtMocHelpers::SlotData<DExpected<LoginExecStatus>()>(21, 2, QMC::AccessPublic, 0x80000000 | 18),
        // Slot 'canReboot'
        QtMocHelpers::SlotData<DExpected<LoginExecStatus>()>(22, 2, QMC::AccessPublic, 0x80000000 | 18),
        // Slot 'canSuspend'
        QtMocHelpers::SlotData<DExpected<LoginExecStatus>()>(23, 2, QMC::AccessPublic, 0x80000000 | 18),
        // Slot 'canSuspendThenHibernate'
        QtMocHelpers::SlotData<DExpected<LoginExecStatus>()>(24, 2, QMC::AccessPublic, 0x80000000 | 18),
        // Slot 'cancelScheduledShutdown'
        QtMocHelpers::SlotData<DExpected<bool>()>(25, 2, QMC::AccessPublic, 0x80000000 | 26),
        // Slot 'findSeatById'
        QtMocHelpers::SlotData<DExpected<LoginSeatPtr>(const QString &)>(27, 2, QMC::AccessPublic, 0x80000000 | 28, {{
            { QMetaType::QString, 6 },
        }}),
        // Slot 'findSessionById'
        QtMocHelpers::SlotData<DExpected<LoginSessionPtr>(const QString &)>(29, 2, QMC::AccessPublic, 0x80000000 | 30, {{
            { QMetaType::QString, 9 },
        }}),
        // Slot 'findSessionByPID'
        QtMocHelpers::SlotData<DExpected<LoginSessionPtr>(quint32)>(31, 2, QMC::AccessPublic, 0x80000000 | 30, {{
            { QMetaType::UInt, 32 },
        }}),
        // Slot 'findUserById'
        QtMocHelpers::SlotData<DExpected<LoginUserPtr>(quint32)>(33, 2, QMC::AccessPublic, 0x80000000 | 34, {{
            { QMetaType::UInt, 12 },
        }}),
        // Slot 'findUserByPID'
        QtMocHelpers::SlotData<DExpected<LoginUserPtr>(quint32)>(35, 2, QMC::AccessPublic, 0x80000000 | 34, {{
            { QMetaType::UInt, 32 },
        }}),
        // Slot 'halt'
        QtMocHelpers::SlotData<DExpected<void>(bool)>(36, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::Bool, 37 },
        }}),
        // Slot 'halt'
        QtMocHelpers::SlotData<DExpected<void>()>(36, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 15),
        // Slot 'hibernate'
        QtMocHelpers::SlotData<DExpected<void>(bool)>(38, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::Bool, 37 },
        }}),
        // Slot 'hibernate'
        QtMocHelpers::SlotData<DExpected<void>()>(38, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 15),
        // Slot 'hybridSleep'
        QtMocHelpers::SlotData<DExpected<void>(bool)>(39, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::Bool, 37 },
        }}),
        // Slot 'hybridSleep'
        QtMocHelpers::SlotData<DExpected<void>()>(39, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 15),
        // Slot 'inhibit'
        QtMocHelpers::SlotData<DExpected<int>(int, const QString &, const QString &, LoginInhibitMode)>(40, 2, QMC::AccessPublic, 0x80000000 | 41, {{
            { QMetaType::Int, 42 }, { QMetaType::QString, 43 }, { QMetaType::QString, 44 }, { 0x80000000 | 45, 46 },
        }}),
        // Slot 'killSession'
        QtMocHelpers::SlotData<DExpected<void>(const QString &, LoginSessionRole, qint32)>(47, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::QString, 9 }, { 0x80000000 | 48, 43 }, { QMetaType::Int, 49 },
        }}),
        // Slot 'killUser'
        QtMocHelpers::SlotData<DExpected<void>(quint32, qint32)>(50, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::UInt, 12 }, { QMetaType::Int, 49 },
        }}),
        // Slot 'listInhibitors'
        QtMocHelpers::SlotData<DExpected<LoginInhibitorList>()>(51, 2, QMC::AccessPublic, 0x80000000 | 52),
        // Slot 'listSeats'
        QtMocHelpers::SlotData<DExpected<QStringList>()>(53, 2, QMC::AccessPublic, 0x80000000 | 54),
        // Slot 'listSessions'
        QtMocHelpers::SlotData<DExpected<QStringList>()>(55, 2, QMC::AccessPublic, 0x80000000 | 54),
        // Slot 'listUsers'
        QtMocHelpers::SlotData<DExpected<QList<quint32>>()>(56, 2, QMC::AccessPublic, 0x80000000 | 57),
        // Slot 'lockSession'
        QtMocHelpers::SlotData<DExpected<void>(const QString &)>(58, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::QString, 9 },
        }}),
        // Slot 'powerOff'
        QtMocHelpers::SlotData<DExpected<void>(bool)>(59, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::Bool, 37 },
        }}),
        // Slot 'powerOff'
        QtMocHelpers::SlotData<DExpected<void>()>(59, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 15),
        // Slot 'reboot'
        QtMocHelpers::SlotData<DExpected<void>(bool)>(60, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::Bool, 37 },
        }}),
        // Slot 'reboot'
        QtMocHelpers::SlotData<DExpected<void>()>(60, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 15),
        // Slot 'scheduleShutdown'
        QtMocHelpers::SlotData<DExpected<void>(LoginShutdownType, const QDateTime &)>(61, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { 0x80000000 | 62, 63 }, { QMetaType::QDateTime, 64 },
        }}),
        // Slot 'setUserLinger'
        QtMocHelpers::SlotData<DExpected<void>(quint32, bool, bool)>(65, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::UInt, 12 }, { QMetaType::Bool, 66 }, { QMetaType::Bool, 37 },
        }}),
        // Slot 'suspend'
        QtMocHelpers::SlotData<DExpected<void>(bool)>(67, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::Bool, 37 },
        }}),
        // Slot 'suspend'
        QtMocHelpers::SlotData<DExpected<void>()>(67, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 15),
        // Slot 'suspendThenHibernate'
        QtMocHelpers::SlotData<DExpected<void>(bool)>(68, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::Bool, 37 },
        }}),
        // Slot 'suspendThenHibernate'
        QtMocHelpers::SlotData<DExpected<void>()>(68, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 15),
        // Slot 'terminateSession'
        QtMocHelpers::SlotData<DExpected<void>(const QString &)>(69, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::QString, 9 },
        }}),
        // Slot 'terminateUser'
        QtMocHelpers::SlotData<DExpected<void>(quint32)>(70, 2, QMC::AccessPublic, 0x80000000 | 15, {{
            { QMetaType::UInt, 71 },
        }}),
        // Slot 'logout'
        QtMocHelpers::SlotData<DExpected<void>()>(72, 2, QMC::AccessPublic, 0x80000000 | 15),
        // Slot 'currentSeat'
        QtMocHelpers::SlotData<DExpected<LoginSeatPtr>()>(73, 2, QMC::AccessPublic, 0x80000000 | 28),
        // Slot 'currentSession'
        QtMocHelpers::SlotData<DExpected<LoginSessionPtr>()>(74, 2, QMC::AccessPublic, 0x80000000 | 30),
        // Slot 'currentUser'
        QtMocHelpers::SlotData<DExpected<LoginUserPtr>()>(75, 2, QMC::AccessPublic, 0x80000000 | 34),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'killExcludeUsers'
        QtMocHelpers::PropertyData<QStringList>(76, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'killOnlyUsers'
        QtMocHelpers::PropertyData<QStringList>(77, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'docked'
        QtMocHelpers::PropertyData<bool>(78, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'idleHint'
        QtMocHelpers::PropertyData<bool>(79, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'killUserProcesses'
        QtMocHelpers::PropertyData<bool>(80, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'lidClosed'
        QtMocHelpers::PropertyData<bool>(81, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'preparingForShutdown'
        QtMocHelpers::PropertyData<bool>(82, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'preparingForSleep'
        QtMocHelpers::PropertyData<bool>(83, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'removeIPC'
        QtMocHelpers::PropertyData<bool>(84, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'blockInhibited'
        QtMocHelpers::PropertyData<QString>(85, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'delayInhibited'
        QtMocHelpers::PropertyData<QString>(86, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'handleHibernateKey'
        QtMocHelpers::PropertyData<PowerAction>(87, 0x80000000 | 88, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'handleLidSwitch'
        QtMocHelpers::PropertyData<PowerAction>(89, 0x80000000 | 88, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'handleLidSwitchDocked'
        QtMocHelpers::PropertyData<PowerAction>(90, 0x80000000 | 88, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'handleLidSwitchExternalPower'
        QtMocHelpers::PropertyData<PowerAction>(91, 0x80000000 | 88, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'handlePowerKey'
        QtMocHelpers::PropertyData<PowerAction>(92, 0x80000000 | 88, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'handleSuspendKey'
        QtMocHelpers::PropertyData<PowerAction>(93, 0x80000000 | 88, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'idleAction'
        QtMocHelpers::PropertyData<PowerAction>(94, 0x80000000 | 88, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'scheduledShutdown'
        QtMocHelpers::PropertyData<ScheduledShutdownValue>(95, 0x80000000 | 96, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'nAutoVTs'
        QtMocHelpers::PropertyData<quint32>(97, QMetaType::UInt, QMC::DefaultPropertyFlags),
        // property 'holdoffTimeoutUSec'
        QtMocHelpers::PropertyData<quint64>(98, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'idleActionUSec'
        QtMocHelpers::PropertyData<quint64>(99, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'idleSinceHint'
        QtMocHelpers::PropertyData<QDateTime>(100, QMetaType::QDateTime, QMC::DefaultPropertyFlags),
        // property 'idleSinceHintMonotonic'
        QtMocHelpers::PropertyData<quint64>(101, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'inhibitDelayMaxUSec'
        QtMocHelpers::PropertyData<quint64>(102, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'inhibitorsMax'
        QtMocHelpers::PropertyData<quint64>(103, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'nCurrentInhibitors'
        QtMocHelpers::PropertyData<quint64>(104, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'nCurrentSessions'
        QtMocHelpers::PropertyData<quint64>(105, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'runtimeDirectoryInodesMax'
        QtMocHelpers::PropertyData<quint64>(106, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'runtimeDirectorySize'
        QtMocHelpers::PropertyData<quint64>(107, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'sessionsMax'
        QtMocHelpers::PropertyData<quint64>(108, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'userStopDelayUSec'
        QtMocHelpers::PropertyData<quint64>(109, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DLoginManager, qt_meta_tag_ZN3Dtk5Login13DLoginManagerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Dtk::Login::DLoginManager::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Dtk5Login13DLoginManagerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Dtk5Login13DLoginManagerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Dtk5Login13DLoginManagerE_t>.metaTypes,
    nullptr
} };

void Dtk::Login::DLoginManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DLoginManager *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->prepareForShutdown((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->prepareForSleep((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->seatNew((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->seatRemoved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 4: _t->sessionNew((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 5: _t->sessionRemoved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 6: _t->userNew((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1]))); break;
        case 7: _t->userRemoved((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1]))); break;
        case 8: { DExpected<void> _r = _t->activateSession((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 9: { DExpected<void> _r = _t->activateSessionOnSeat((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 10: { DExpected<LoginExecStatus> _r = _t->canHalt();
            if (_a[0]) *reinterpret_cast<DExpected<LoginExecStatus>*>(_a[0]) = std::move(_r); }  break;
        case 11: { DExpected<LoginExecStatus> _r = _t->canHibernate();
            if (_a[0]) *reinterpret_cast<DExpected<LoginExecStatus>*>(_a[0]) = std::move(_r); }  break;
        case 12: { DExpected<LoginExecStatus> _r = _t->canHybridSleep();
            if (_a[0]) *reinterpret_cast<DExpected<LoginExecStatus>*>(_a[0]) = std::move(_r); }  break;
        case 13: { DExpected<LoginExecStatus> _r = _t->canPowerOff();
            if (_a[0]) *reinterpret_cast<DExpected<LoginExecStatus>*>(_a[0]) = std::move(_r); }  break;
        case 14: { DExpected<LoginExecStatus> _r = _t->canReboot();
            if (_a[0]) *reinterpret_cast<DExpected<LoginExecStatus>*>(_a[0]) = std::move(_r); }  break;
        case 15: { DExpected<LoginExecStatus> _r = _t->canSuspend();
            if (_a[0]) *reinterpret_cast<DExpected<LoginExecStatus>*>(_a[0]) = std::move(_r); }  break;
        case 16: { DExpected<LoginExecStatus> _r = _t->canSuspendThenHibernate();
            if (_a[0]) *reinterpret_cast<DExpected<LoginExecStatus>*>(_a[0]) = std::move(_r); }  break;
        case 17: { DExpected<bool> _r = _t->cancelScheduledShutdown();
            if (_a[0]) *reinterpret_cast<DExpected<bool>*>(_a[0]) = std::move(_r); }  break;
        case 18: { DExpected<LoginSeatPtr> _r = _t->findSeatById((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<LoginSeatPtr>*>(_a[0]) = std::move(_r); }  break;
        case 19: { DExpected<LoginSessionPtr> _r = _t->findSessionById((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<LoginSessionPtr>*>(_a[0]) = std::move(_r); }  break;
        case 20: { DExpected<LoginSessionPtr> _r = _t->findSessionByPID((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<LoginSessionPtr>*>(_a[0]) = std::move(_r); }  break;
        case 21: { DExpected<LoginUserPtr> _r = _t->findUserById((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<LoginUserPtr>*>(_a[0]) = std::move(_r); }  break;
        case 22: { DExpected<LoginUserPtr> _r = _t->findUserByPID((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<LoginUserPtr>*>(_a[0]) = std::move(_r); }  break;
        case 23: { DExpected<void> _r = _t->halt((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 24: { DExpected<void> _r = _t->halt();
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 25: { DExpected<void> _r = _t->hibernate((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 26: { DExpected<void> _r = _t->hibernate();
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 27: { DExpected<void> _r = _t->hybridSleep((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 28: { DExpected<void> _r = _t->hybridSleep();
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 29: { DExpected<int> _r = _t->inhibit((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<LoginInhibitMode>>(_a[4])));
            if (_a[0]) *reinterpret_cast<DExpected<int>*>(_a[0]) = std::move(_r); }  break;
        case 30: { DExpected<void> _r = _t->killSession((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<LoginSessionRole>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<qint32>>(_a[3])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 31: { DExpected<void> _r = _t->killUser((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qint32>>(_a[2])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 32: { DExpected<LoginInhibitorList> _r = _t->listInhibitors();
            if (_a[0]) *reinterpret_cast<DExpected<LoginInhibitorList>*>(_a[0]) = std::move(_r); }  break;
        case 33: { DExpected<QStringList> _r = _t->listSeats();
            if (_a[0]) *reinterpret_cast<DExpected<QStringList>*>(_a[0]) = std::move(_r); }  break;
        case 34: { DExpected<QStringList> _r = _t->listSessions();
            if (_a[0]) *reinterpret_cast<DExpected<QStringList>*>(_a[0]) = std::move(_r); }  break;
        case 35: { DExpected<QList<quint32>> _r = _t->listUsers();
            if (_a[0]) *reinterpret_cast<DExpected<QList<quint32>>*>(_a[0]) = std::move(_r); }  break;
        case 36: { DExpected<void> _r = _t->lockSession((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 37: { DExpected<void> _r = _t->powerOff((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 38: { DExpected<void> _r = _t->powerOff();
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 39: { DExpected<void> _r = _t->reboot((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 40: { DExpected<void> _r = _t->reboot();
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 41: { DExpected<void> _r = _t->scheduleShutdown((*reinterpret_cast<std::add_pointer_t<LoginShutdownType>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDateTime>>(_a[2])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 42: { DExpected<void> _r = _t->setUserLinger((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 43: { DExpected<void> _r = _t->suspend((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 44: { DExpected<void> _r = _t->suspend();
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 45: { DExpected<void> _r = _t->suspendThenHibernate((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 46: { DExpected<void> _r = _t->suspendThenHibernate();
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 47: { DExpected<void> _r = _t->terminateSession((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 48: { DExpected<void> _r = _t->terminateUser((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 49: { DExpected<void> _r = _t->logout();
            if (_a[0]) *reinterpret_cast<DExpected<void>*>(_a[0]) = std::move(_r); }  break;
        case 50: { DExpected<LoginSeatPtr> _r = _t->currentSeat();
            if (_a[0]) *reinterpret_cast<DExpected<LoginSeatPtr>*>(_a[0]) = std::move(_r); }  break;
        case 51: { DExpected<LoginSessionPtr> _r = _t->currentSession();
            if (_a[0]) *reinterpret_cast<DExpected<LoginSessionPtr>*>(_a[0]) = std::move(_r); }  break;
        case 52: { DExpected<LoginUserPtr> _r = _t->currentUser();
            if (_a[0]) *reinterpret_cast<DExpected<LoginUserPtr>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DLoginManager::*)(bool )>(_a, &DLoginManager::prepareForShutdown, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DLoginManager::*)(bool )>(_a, &DLoginManager::prepareForSleep, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DLoginManager::*)(const QString & )>(_a, &DLoginManager::seatNew, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (DLoginManager::*)(const QString & )>(_a, &DLoginManager::seatRemoved, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (DLoginManager::*)(const QString & )>(_a, &DLoginManager::sessionNew, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (DLoginManager::*)(const QString & )>(_a, &DLoginManager::sessionRemoved, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (DLoginManager::*)(quint32 )>(_a, &DLoginManager::userNew, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (DLoginManager::*)(quint32 )>(_a, &DLoginManager::userRemoved, 7))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QStringList*>(_v) = _t->killExcludeUsers(); break;
        case 1: *reinterpret_cast<QStringList*>(_v) = _t->killOnlyUsers(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->docked(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->idleHint(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->killUserProcesses(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->lidClosed(); break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->preparingForShutdown(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->preparingForSleep(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->removeIPC(); break;
        case 9: *reinterpret_cast<QString*>(_v) = _t->blockInhibited(); break;
        case 10: *reinterpret_cast<QString*>(_v) = _t->delayInhibited(); break;
        case 11: *reinterpret_cast<PowerAction*>(_v) = _t->handleHibernateKey(); break;
        case 12: *reinterpret_cast<PowerAction*>(_v) = _t->handleLidSwitch(); break;
        case 13: *reinterpret_cast<PowerAction*>(_v) = _t->handleLidSwitchDocked(); break;
        case 14: *reinterpret_cast<PowerAction*>(_v) = _t->handleLidSwitchExternalPower(); break;
        case 15: *reinterpret_cast<PowerAction*>(_v) = _t->handlePowerKey(); break;
        case 16: *reinterpret_cast<PowerAction*>(_v) = _t->handleSuspendKey(); break;
        case 17: *reinterpret_cast<PowerAction*>(_v) = _t->idleAction(); break;
        case 18: *reinterpret_cast<ScheduledShutdownValue*>(_v) = _t->scheduledShutdown(); break;
        case 19: *reinterpret_cast<quint32*>(_v) = _t->nAutoVTs(); break;
        case 20: *reinterpret_cast<quint64*>(_v) = _t->holdoffTimeoutUSec(); break;
        case 21: *reinterpret_cast<quint64*>(_v) = _t->idleActionUSec(); break;
        case 22: *reinterpret_cast<QDateTime*>(_v) = _t->idleSinceHint(); break;
        case 23: *reinterpret_cast<quint64*>(_v) = _t->idleSinceHintMonotonic(); break;
        case 24: *reinterpret_cast<quint64*>(_v) = _t->inhibitDelayMaxUSec(); break;
        case 25: *reinterpret_cast<quint64*>(_v) = _t->inhibitorsMax(); break;
        case 26: *reinterpret_cast<quint64*>(_v) = _t->nCurrentInhibitors(); break;
        case 27: *reinterpret_cast<quint64*>(_v) = _t->nCurrentSessions(); break;
        case 28: *reinterpret_cast<quint64*>(_v) = _t->runtimeDirectoryInodesMax(); break;
        case 29: *reinterpret_cast<quint64*>(_v) = _t->runtimeDirectorySize(); break;
        case 30: *reinterpret_cast<quint64*>(_v) = _t->sessionsMax(); break;
        case 31: *reinterpret_cast<quint64*>(_v) = _t->userStopDelayUSec(); break;
        default: break;
        }
    }
}

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

void *Dtk::Login::DLoginManager::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Dtk5Login13DLoginManagerE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int Dtk::Login::DLoginManager::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 53)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 53;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 53)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 53;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 32;
    }
    return _id;
}

// SIGNAL 0
void Dtk::Login::DLoginManager::prepareForShutdown(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void Dtk::Login::DLoginManager::prepareForSleep(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void Dtk::Login::DLoginManager::seatNew(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void Dtk::Login::DLoginManager::seatRemoved(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void Dtk::Login::DLoginManager::sessionNew(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void Dtk::Login::DLoginManager::sessionRemoved(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void Dtk::Login::DLoginManager::userNew(quint32 _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void Dtk::Login::DLoginManager::userRemoved(quint32 _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}
QT_WARNING_POP
