/****************************************************************************
** Meta object code from reading C++ file 'login1managerinterface.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 "../../login/dbus/login1managerinterface.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 'login1managerinterface.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_ZN3Dtk5Login22Login1ManagerInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto Dtk::Login::Login1ManagerInterface::qt_create_metaobjectdata<qt_meta_tag_ZN3Dtk5Login22Login1ManagerInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Dtk::Login::Login1ManagerInterface",
        "prepareForShutdown",
        "",
        "value",
        "prepareForSleep",
        "seatNew",
        "seatId",
        "QDBusObjectPath",
        "seatPath",
        "seatRemoved",
        "sessionNew",
        "sessionId",
        "sessionPath",
        "sessionRemoved",
        "userNew",
        "UID",
        "userRemoved",
        "activateSession",
        "QDBusPendingReply<>",
        "activateSessionOnSeat",
        "attachDevice",
        "sysfsPath",
        "interactive",
        "canHalt",
        "QDBusPendingReply<QString>",
        "canHibernate",
        "canHybridSleep",
        "canPowerOff",
        "canReboot",
        "canRebootParameter",
        "canRebootToBootLoaderEntry",
        "canRebootToBootLoaderMenu",
        "canRebootToFirmwareSetup",
        "canSuspend",
        "canSuspendThenHibernate",
        "cancelScheduledShutdown",
        "QDBusPendingReply<bool>",
        "flushDevices",
        "getSeat",
        "QDBusPendingReply<QDBusObjectPath>",
        "getSession",
        "getSessionByPID",
        "pid",
        "getUser",
        "getUserByPID",
        "halt",
        "haltWithFlags",
        "flags",
        "hibernate",
        "hibernateWithFlags",
        "hybridSleep",
        "hybridSleepWithFlags",
        "inhibit",
        "QDBusPendingReply<QDBusUnixFileDescriptor>",
        "what",
        "who",
        "why",
        "mode",
        "killSession",
        "signalNumber",
        "killUser",
        "signalName",
        "listInhibitors",
        "QDBusPendingReply<QList<DBusInhibitor>>",
        "listSeats",
        "QDBusPendingReply<QList<Dtk::Login::DBusSeat>>",
        "listSessions",
        "QDBusPendingReply<QList<Dtk::Login::DBusSession>>",
        "listUsers",
        "QDBusPendingReply<QList<Dtk::Login::DBusUser>>",
        "lockSession",
        "lockSessions",
        "powerOff",
        "powerOffWithFlags",
        "reboot",
        "rebootWithFlags",
        "releaseSession",
        "scheduleShutdown",
        "type",
        "usec",
        "setRebootParameter",
        "parameter",
        "setRebootToBootLoaderEntry",
        "bootLoaderEntry",
        "setRebootToBootLoaderMenu",
        "timeout",
        "setRebootToFirmwareSetup",
        "enable",
        "setUserLinger",
        "suspend",
        "suspendWithFlags",
        "suspendThenHibernate",
        "suspendThenHibernateWithFlags",
        "terminateSeat",
        "terminateSession",
        "terminateUser",
        "unlockSession",
        "unlockSessions",
        "bootLoaderEntries",
        "killExcludeUsers",
        "killOnlyUsers",
        "docked",
        "enableWallMessages",
        "idleHint",
        "killUserProcesses",
        "lidClosed",
        "onExternalPower",
        "preparingForShutdown",
        "preparingForSleep",
        "rebootToFirmwareSetup",
        "removeIPC",
        "blockInhibited",
        "delayInhibited",
        "handleHibernateKey",
        "handleLidSwitch",
        "handleLidSwitchDocked",
        "handleLidSwitchExternalPower",
        "handlePowerKey",
        "handleSuspendKey",
        "idleAction",
        "rebootParameter",
        "rebootToBootLoaderEntry",
        "wallMessage",
        "scheduledShutdown",
        "DBusScheduledShutdownValue",
        "nAutoVTs",
        "holdoffTimeoutUSec",
        "idleActionUSec",
        "idleSinceHint",
        "idleSinceHintMonotonic",
        "inhibitDelayMaxUSec",
        "inhibitorsMax",
        "nCurrentInhibitors",
        "nCurrentSessions",
        "rebootToBootLoaderMenu",
        "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 &, const QDBusObjectPath &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 6 }, { 0x80000000 | 7, 8 },
        }}),
        // Signal 'seatRemoved'
        QtMocHelpers::SignalData<void(const QString &, const QDBusObjectPath &)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 6 }, { 0x80000000 | 7, 8 },
        }}),
        // Signal 'sessionNew'
        QtMocHelpers::SignalData<void(const QString &, const QDBusObjectPath &)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 11 }, { 0x80000000 | 7, 12 },
        }}),
        // Signal 'sessionRemoved'
        QtMocHelpers::SignalData<void(const QString &, const QDBusObjectPath &)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 11 }, { 0x80000000 | 7, 12 },
        }}),
        // Signal 'userNew'
        QtMocHelpers::SignalData<void(quint32, const QDBusObjectPath &)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 15 }, { 0x80000000 | 7, 8 },
        }}),
        // Signal 'userRemoved'
        QtMocHelpers::SignalData<void(quint32, const QDBusObjectPath &)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 15 }, { 0x80000000 | 7, 8 },
        }}),
        // Slot 'activateSession'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(17, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'activateSessionOnSeat'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &, const QString &)>(19, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 11 }, { QMetaType::QString, 6 },
        }}),
        // Slot 'attachDevice'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &, const QString &, bool)>(20, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 6 }, { QMetaType::QString, 21 }, { QMetaType::Bool, 22 },
        }}),
        // Slot 'canHalt'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(23, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'canHibernate'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(25, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'canHybridSleep'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(26, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'canPowerOff'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(27, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'canReboot'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(28, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'canRebootParameter'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(29, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'canRebootToBootLoaderEntry'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(30, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'canRebootToBootLoaderMenu'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(31, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'canRebootToFirmwareSetup'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(32, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'canSuspend'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(33, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'canSuspendThenHibernate'
        QtMocHelpers::SlotData<QDBusPendingReply<QString>()>(34, 2, QMC::AccessPublic, 0x80000000 | 24),
        // Slot 'cancelScheduledShutdown'
        QtMocHelpers::SlotData<QDBusPendingReply<bool>()>(35, 2, QMC::AccessPublic, 0x80000000 | 36),
        // Slot 'flushDevices'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(37, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::Bool, 22 },
        }}),
        // Slot 'getSeat'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &)>(38, 2, QMC::AccessPublic, 0x80000000 | 39, {{
            { QMetaType::QString, 6 },
        }}),
        // Slot 'getSession'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(const QString &)>(40, 2, QMC::AccessPublic, 0x80000000 | 39, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'getSessionByPID'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(quint32)>(41, 2, QMC::AccessPublic, 0x80000000 | 39, {{
            { QMetaType::UInt, 42 },
        }}),
        // Slot 'getUser'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(quint32)>(43, 2, QMC::AccessPublic, 0x80000000 | 39, {{
            { QMetaType::UInt, 15 },
        }}),
        // Slot 'getUserByPID'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusObjectPath>(quint32)>(44, 2, QMC::AccessPublic, 0x80000000 | 39, {{
            { QMetaType::UInt, 42 },
        }}),
        // Slot 'halt'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(45, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::Bool, 22 },
        }}),
        // Slot 'haltWithFlags'
        QtMocHelpers::SlotData<QDBusPendingReply<>(quint64)>(46, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::ULongLong, 47 },
        }}),
        // Slot 'hibernate'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(48, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::Bool, 22 },
        }}),
        // Slot 'hibernateWithFlags'
        QtMocHelpers::SlotData<QDBusPendingReply<>(quint64)>(49, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::ULongLong, 47 },
        }}),
        // Slot 'hybridSleep'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(50, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::Bool, 22 },
        }}),
        // Slot 'hybridSleepWithFlags'
        QtMocHelpers::SlotData<QDBusPendingReply<>(quint64)>(51, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::ULongLong, 47 },
        }}),
        // Slot 'inhibit'
        QtMocHelpers::SlotData<QDBusPendingReply<QDBusUnixFileDescriptor>(const QString &, const QString &, const QString &, const QString &)>(52, 2, QMC::AccessPublic, 0x80000000 | 53, {{
            { QMetaType::QString, 54 }, { QMetaType::QString, 55 }, { QMetaType::QString, 56 }, { QMetaType::QString, 57 },
        }}),
        // Slot 'killSession'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &, const QString &, qint32)>(58, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 11 }, { QMetaType::QString, 55 }, { QMetaType::Int, 59 },
        }}),
        // Slot 'killUser'
        QtMocHelpers::SlotData<QDBusPendingReply<>(quint32, qint32)>(60, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::UInt, 15 }, { QMetaType::Int, 61 },
        }}),
        // Slot 'listInhibitors'
        QtMocHelpers::SlotData<QDBusPendingReply<QList<DBusInhibitor>>()>(62, 2, QMC::AccessPublic, 0x80000000 | 63),
        // Slot 'listSeats'
        QtMocHelpers::SlotData<QDBusPendingReply<QList<Dtk::Login::DBusSeat>>()>(64, 2, QMC::AccessPublic, 0x80000000 | 65),
        // Slot 'listSessions'
        QtMocHelpers::SlotData<QDBusPendingReply<QList<Dtk::Login::DBusSession>>()>(66, 2, QMC::AccessPublic, 0x80000000 | 67),
        // Slot 'listUsers'
        QtMocHelpers::SlotData<QDBusPendingReply<QList<Dtk::Login::DBusUser>>()>(68, 2, QMC::AccessPublic, 0x80000000 | 69),
        // Slot 'lockSession'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(70, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'lockSessions'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(71, 2, QMC::AccessPublic, 0x80000000 | 18),
        // Slot 'powerOff'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(72, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::Bool, 22 },
        }}),
        // Slot 'powerOffWithFlags'
        QtMocHelpers::SlotData<QDBusPendingReply<>(quint64)>(73, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::ULongLong, 47 },
        }}),
        // Slot 'reboot'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(74, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::Bool, 22 },
        }}),
        // Slot 'rebootWithFlags'
        QtMocHelpers::SlotData<QDBusPendingReply<>(quint64)>(75, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::ULongLong, 47 },
        }}),
        // Slot 'releaseSession'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(76, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'scheduleShutdown'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &, quint64)>(77, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 78 }, { QMetaType::ULongLong, 79 },
        }}),
        // Slot 'setRebootParameter'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(80, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 81 },
        }}),
        // Slot 'setRebootToBootLoaderEntry'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(82, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 83 },
        }}),
        // Slot 'setRebootToBootLoaderMenu'
        QtMocHelpers::SlotData<QDBusPendingReply<>(quint64)>(84, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::ULongLong, 85 },
        }}),
        // Slot 'setRebootToFirmwareSetup'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(86, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::Bool, 87 },
        }}),
        // Slot 'setUserLinger'
        QtMocHelpers::SlotData<QDBusPendingReply<>(quint32, bool, bool)>(88, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::UInt, 15 }, { QMetaType::Bool, 87 }, { QMetaType::Bool, 22 },
        }}),
        // Slot 'suspend'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(89, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::Bool, 22 },
        }}),
        // Slot 'suspendWithFlags'
        QtMocHelpers::SlotData<QDBusPendingReply<>(quint64)>(90, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::ULongLong, 47 },
        }}),
        // Slot 'suspendThenHibernate'
        QtMocHelpers::SlotData<QDBusPendingReply<>(bool)>(91, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::Bool, 22 },
        }}),
        // Slot 'suspendThenHibernateWithFlags'
        QtMocHelpers::SlotData<QDBusPendingReply<>(quint64)>(92, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::ULongLong, 47 },
        }}),
        // Slot 'terminateSeat'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(93, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 6 },
        }}),
        // Slot 'terminateSession'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(94, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'terminateUser'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const quint32)>(95, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::UInt, 15 },
        }}),
        // Slot 'unlockSession'
        QtMocHelpers::SlotData<QDBusPendingReply<>(const QString &)>(96, 2, QMC::AccessPublic, 0x80000000 | 18, {{
            { QMetaType::QString, 11 },
        }}),
        // Slot 'unlockSessions'
        QtMocHelpers::SlotData<QDBusPendingReply<>()>(97, 2, QMC::AccessPublic, 0x80000000 | 18),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'bootLoaderEntries'
        QtMocHelpers::PropertyData<QStringList>(98, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'killExcludeUsers'
        QtMocHelpers::PropertyData<QStringList>(99, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'killOnlyUsers'
        QtMocHelpers::PropertyData<QStringList>(100, QMetaType::QStringList, QMC::DefaultPropertyFlags),
        // property 'docked'
        QtMocHelpers::PropertyData<bool>(101, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'enableWallMessages'
        QtMocHelpers::PropertyData<bool>(102, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'idleHint'
        QtMocHelpers::PropertyData<bool>(103, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'killUserProcesses'
        QtMocHelpers::PropertyData<bool>(104, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'lidClosed'
        QtMocHelpers::PropertyData<bool>(105, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'onExternalPower'
        QtMocHelpers::PropertyData<bool>(106, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'preparingForShutdown'
        QtMocHelpers::PropertyData<bool>(107, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'preparingForSleep'
        QtMocHelpers::PropertyData<bool>(108, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'rebootToFirmwareSetup'
        QtMocHelpers::PropertyData<bool>(109, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'removeIPC'
        QtMocHelpers::PropertyData<bool>(110, QMetaType::Bool, QMC::DefaultPropertyFlags),
        // property 'blockInhibited'
        QtMocHelpers::PropertyData<QString>(111, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'delayInhibited'
        QtMocHelpers::PropertyData<QString>(112, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'handleHibernateKey'
        QtMocHelpers::PropertyData<QString>(113, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'handleLidSwitch'
        QtMocHelpers::PropertyData<QString>(114, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'handleLidSwitchDocked'
        QtMocHelpers::PropertyData<QString>(115, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'handleLidSwitchExternalPower'
        QtMocHelpers::PropertyData<QString>(116, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'handlePowerKey'
        QtMocHelpers::PropertyData<QString>(117, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'handleSuspendKey'
        QtMocHelpers::PropertyData<QString>(118, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'idleAction'
        QtMocHelpers::PropertyData<QString>(119, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'rebootParameter'
        QtMocHelpers::PropertyData<QString>(120, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'rebootToBootLoaderEntry'
        QtMocHelpers::PropertyData<QString>(121, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'wallMessage'
        QtMocHelpers::PropertyData<QString>(122, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'scheduledShutdown'
        QtMocHelpers::PropertyData<DBusScheduledShutdownValue>(123, 0x80000000 | 124, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'nAutoVTs'
        QtMocHelpers::PropertyData<quint32>(125, QMetaType::UInt, QMC::DefaultPropertyFlags),
        // property 'holdoffTimeoutUSec'
        QtMocHelpers::PropertyData<quint64>(126, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'idleActionUSec'
        QtMocHelpers::PropertyData<quint64>(127, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'idleSinceHint'
        QtMocHelpers::PropertyData<quint64>(128, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'idleSinceHintMonotonic'
        QtMocHelpers::PropertyData<quint64>(129, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'inhibitDelayMaxUSec'
        QtMocHelpers::PropertyData<quint64>(130, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'inhibitorsMax'
        QtMocHelpers::PropertyData<quint64>(131, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'nCurrentInhibitors'
        QtMocHelpers::PropertyData<quint64>(132, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'nCurrentSessions'
        QtMocHelpers::PropertyData<quint64>(133, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'rebootToBootLoaderMenu'
        QtMocHelpers::PropertyData<quint64>(134, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'runtimeDirectoryInodesMax'
        QtMocHelpers::PropertyData<quint64>(135, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'runtimeDirectorySize'
        QtMocHelpers::PropertyData<quint64>(136, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'sessionsMax'
        QtMocHelpers::PropertyData<quint64>(137, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
        // property 'userStopDelayUSec'
        QtMocHelpers::PropertyData<quint64>(138, QMetaType::ULongLong, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Login1ManagerInterface, qt_meta_tag_ZN3Dtk5Login22Login1ManagerInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Dtk::Login::Login1ManagerInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Dtk5Login22Login1ManagerInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3Dtk5Login22Login1ManagerInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3Dtk5Login22Login1ManagerInterfaceE_t>.metaTypes,
    nullptr
} };

void Dtk::Login::Login1ManagerInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Login1ManagerInterface *>(_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])),(*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[2]))); break;
        case 3: _t->seatRemoved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[2]))); break;
        case 4: _t->sessionNew((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[2]))); break;
        case 5: _t->sessionRemoved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[2]))); break;
        case 6: _t->userNew((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[2]))); break;
        case 7: _t->userRemoved((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[2]))); break;
        case 8: { QDBusPendingReply<> _r = _t->activateSession((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 9: { QDBusPendingReply<> _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<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 10: { QDBusPendingReply<> _r = _t->attachDevice((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 11: { QDBusPendingReply<QString> _r = _t->canHalt();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 12: { QDBusPendingReply<QString> _r = _t->canHibernate();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 13: { QDBusPendingReply<QString> _r = _t->canHybridSleep();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 14: { QDBusPendingReply<QString> _r = _t->canPowerOff();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 15: { QDBusPendingReply<QString> _r = _t->canReboot();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 16: { QDBusPendingReply<QString> _r = _t->canRebootParameter();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 17: { QDBusPendingReply<QString> _r = _t->canRebootToBootLoaderEntry();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 18: { QDBusPendingReply<QString> _r = _t->canRebootToBootLoaderMenu();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 19: { QDBusPendingReply<QString> _r = _t->canRebootToFirmwareSetup();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 20: { QDBusPendingReply<QString> _r = _t->canSuspend();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 21: { QDBusPendingReply<QString> _r = _t->canSuspendThenHibernate();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QString>*>(_a[0]) = std::move(_r); }  break;
        case 22: { QDBusPendingReply<bool> _r = _t->cancelScheduledShutdown();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<bool>*>(_a[0]) = std::move(_r); }  break;
        case 23: { QDBusPendingReply<> _r = _t->flushDevices((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 24: { QDBusPendingReply<QDBusObjectPath> _r = _t->getSeat((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 25: { QDBusPendingReply<QDBusObjectPath> _r = _t->getSession((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 26: { QDBusPendingReply<QDBusObjectPath> _r = _t->getSessionByPID((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 27: { QDBusPendingReply<QDBusObjectPath> _r = _t->getUser((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 28: { QDBusPendingReply<QDBusObjectPath> _r = _t->getUserByPID((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusObjectPath>*>(_a[0]) = std::move(_r); }  break;
        case 29: { QDBusPendingReply<> _r = _t->halt((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 30: { QDBusPendingReply<> _r = _t->haltWithFlags((*reinterpret_cast<std::add_pointer_t<quint64>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 31: { QDBusPendingReply<> _r = _t->hibernate((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 32: { QDBusPendingReply<> _r = _t->hibernateWithFlags((*reinterpret_cast<std::add_pointer_t<quint64>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 33: { QDBusPendingReply<> _r = _t->hybridSleep((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 34: { QDBusPendingReply<> _r = _t->hybridSleepWithFlags((*reinterpret_cast<std::add_pointer_t<quint64>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 35: { QDBusPendingReply<QDBusUnixFileDescriptor> _r = _t->inhibit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QDBusUnixFileDescriptor>*>(_a[0]) = std::move(_r); }  break;
        case 36: { QDBusPendingReply<> _r = _t->killSession((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<qint32>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 37: { QDBusPendingReply<> _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<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 38: { QDBusPendingReply<QList<DBusInhibitor>> _r = _t->listInhibitors();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QList<DBusInhibitor>>*>(_a[0]) = std::move(_r); }  break;
        case 39: { QDBusPendingReply<QList<Dtk::Login::DBusSeat>> _r = _t->listSeats();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QList<Dtk::Login::DBusSeat>>*>(_a[0]) = std::move(_r); }  break;
        case 40: { QDBusPendingReply<QList<Dtk::Login::DBusSession>> _r = _t->listSessions();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QList<Dtk::Login::DBusSession>>*>(_a[0]) = std::move(_r); }  break;
        case 41: { QDBusPendingReply<QList<Dtk::Login::DBusUser>> _r = _t->listUsers();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<QList<Dtk::Login::DBusUser>>*>(_a[0]) = std::move(_r); }  break;
        case 42: { QDBusPendingReply<> _r = _t->lockSession((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 43: { QDBusPendingReply<> _r = _t->lockSessions();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 44: { QDBusPendingReply<> _r = _t->powerOff((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 45: { QDBusPendingReply<> _r = _t->powerOffWithFlags((*reinterpret_cast<std::add_pointer_t<quint64>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 46: { QDBusPendingReply<> _r = _t->reboot((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 47: { QDBusPendingReply<> _r = _t->rebootWithFlags((*reinterpret_cast<std::add_pointer_t<quint64>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 48: { QDBusPendingReply<> _r = _t->releaseSession((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 49: { QDBusPendingReply<> _r = _t->scheduleShutdown((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 50: { QDBusPendingReply<> _r = _t->setRebootParameter((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 51: { QDBusPendingReply<> _r = _t->setRebootToBootLoaderEntry((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 52: { QDBusPendingReply<> _r = _t->setRebootToBootLoaderMenu((*reinterpret_cast<std::add_pointer_t<quint64>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 53: { QDBusPendingReply<> _r = _t->setRebootToFirmwareSetup((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 54: { QDBusPendingReply<> _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<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 55: { QDBusPendingReply<> _r = _t->suspend((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 56: { QDBusPendingReply<> _r = _t->suspendWithFlags((*reinterpret_cast<std::add_pointer_t<quint64>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 57: { QDBusPendingReply<> _r = _t->suspendThenHibernate((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 58: { QDBusPendingReply<> _r = _t->suspendThenHibernateWithFlags((*reinterpret_cast<std::add_pointer_t<quint64>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 59: { QDBusPendingReply<> _r = _t->terminateSeat((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 60: { QDBusPendingReply<> _r = _t->terminateSession((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 61: { QDBusPendingReply<> _r = _t->terminateUser((*reinterpret_cast<std::add_pointer_t<quint32>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 62: { QDBusPendingReply<> _r = _t->unlockSession((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        case 63: { QDBusPendingReply<> _r = _t->unlockSessions();
            if (_a[0]) *reinterpret_cast<QDBusPendingReply<>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        case 4:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Login1ManagerInterface::*)(bool )>(_a, &Login1ManagerInterface::prepareForShutdown, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Login1ManagerInterface::*)(bool )>(_a, &Login1ManagerInterface::prepareForSleep, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Login1ManagerInterface::*)(const QString & , const QDBusObjectPath & )>(_a, &Login1ManagerInterface::seatNew, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Login1ManagerInterface::*)(const QString & , const QDBusObjectPath & )>(_a, &Login1ManagerInterface::seatRemoved, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Login1ManagerInterface::*)(const QString & , const QDBusObjectPath & )>(_a, &Login1ManagerInterface::sessionNew, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Login1ManagerInterface::*)(const QString & , const QDBusObjectPath & )>(_a, &Login1ManagerInterface::sessionRemoved, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Login1ManagerInterface::*)(quint32 , const QDBusObjectPath & )>(_a, &Login1ManagerInterface::userNew, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Login1ManagerInterface::*)(quint32 , const QDBusObjectPath & )>(_a, &Login1ManagerInterface::userRemoved, 7))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QStringList*>(_v) = _t->bootLoaderEntries(); break;
        case 1: *reinterpret_cast<QStringList*>(_v) = _t->killExcludeUsers(); break;
        case 2: *reinterpret_cast<QStringList*>(_v) = _t->killOnlyUsers(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->docked(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->enableWallMessages(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->idleHint(); break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->killUserProcesses(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->lidClosed(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->onExternalPower(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->preparingForShutdown(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->preparingForSleep(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->rebootToFirmwareSetup(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->removeIPC(); break;
        case 13: *reinterpret_cast<QString*>(_v) = _t->blockInhibited(); break;
        case 14: *reinterpret_cast<QString*>(_v) = _t->delayInhibited(); break;
        case 15: *reinterpret_cast<QString*>(_v) = _t->handleHibernateKey(); break;
        case 16: *reinterpret_cast<QString*>(_v) = _t->handleLidSwitch(); break;
        case 17: *reinterpret_cast<QString*>(_v) = _t->handleLidSwitchDocked(); break;
        case 18: *reinterpret_cast<QString*>(_v) = _t->handleLidSwitchExternalPower(); break;
        case 19: *reinterpret_cast<QString*>(_v) = _t->handlePowerKey(); break;
        case 20: *reinterpret_cast<QString*>(_v) = _t->handleSuspendKey(); break;
        case 21: *reinterpret_cast<QString*>(_v) = _t->idleAction(); break;
        case 22: *reinterpret_cast<QString*>(_v) = _t->rebootParameter(); break;
        case 23: *reinterpret_cast<QString*>(_v) = _t->rebootToBootLoaderEntry(); break;
        case 24: *reinterpret_cast<QString*>(_v) = _t->wallMessage(); break;
        case 25: *reinterpret_cast<DBusScheduledShutdownValue*>(_v) = _t->scheduledShutdown(); break;
        case 26: *reinterpret_cast<quint32*>(_v) = _t->nAutoVTs(); break;
        case 27: *reinterpret_cast<quint64*>(_v) = _t->holdoffTimeoutUSec(); break;
        case 28: *reinterpret_cast<quint64*>(_v) = _t->idleActionUSec(); break;
        case 29: *reinterpret_cast<quint64*>(_v) = _t->idleSinceHint(); break;
        case 30: *reinterpret_cast<quint64*>(_v) = _t->idleSinceHintMonotonic(); break;
        case 31: *reinterpret_cast<quint64*>(_v) = _t->inhibitDelayMaxUSec(); break;
        case 32: *reinterpret_cast<quint64*>(_v) = _t->inhibitorsMax(); break;
        case 33: *reinterpret_cast<quint64*>(_v) = _t->nCurrentInhibitors(); break;
        case 34: *reinterpret_cast<quint64*>(_v) = _t->nCurrentSessions(); break;
        case 35: *reinterpret_cast<quint64*>(_v) = _t->rebootToBootLoaderMenu(); break;
        case 36: *reinterpret_cast<quint64*>(_v) = _t->runtimeDirectoryInodesMax(); break;
        case 37: *reinterpret_cast<quint64*>(_v) = _t->runtimeDirectorySize(); break;
        case 38: *reinterpret_cast<quint64*>(_v) = _t->sessionsMax(); break;
        case 39: *reinterpret_cast<quint64*>(_v) = _t->userStopDelayUSec(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 4: _t->setEnableWallMessages(*reinterpret_cast<bool*>(_v)); break;
        case 24: _t->setWallMessage(*reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}

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

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

int Dtk::Login::Login1ManagerInterface::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 < 64)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 64;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 64)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 64;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 40;
    }
    return _id;
}

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

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

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

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

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

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

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

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