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

#include "../../src/session-widgets/sessionbasemodel.h"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'sessionbasemodel.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.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_ZN16SessionBaseModelE_t {};
} // unnamed namespace

template <> constexpr inline auto SessionBaseModel::qt_create_metaobjectdata<qt_meta_tag_ZN16SessionBaseModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "SessionBaseModel",
        "currentUserChanged",
        "",
        "std::shared_ptr<User>",
        "userAdded",
        "userRemoved",
        "userListChanged",
        "QList<std::shared_ptr<User>>",
        "loginedUserListChanged",
        "MFAFlagChanged",
        "visibleChanged",
        "lightdmPamStartedChanged",
        "authTipsMessage",
        "message",
        "AuthFailedType",
        "type",
        "authFailedMessage",
        "authFailedTipsMessage",
        "authFinished",
        "success",
        "accountError",
        "checkAccountFinished",
        "onPowerActionChanged",
        "PowerAction",
        "poweraction",
        "onRequirePowerAction",
        "needConfirm",
        "onSessionKeyChanged",
        "sessionKey",
        "showUserList",
        "showLockScreen",
        "showShutdown",
        "showUpdate",
        "doReboot",
        "onStatusChanged",
        "ModeStatus",
        "status",
        "onUserListChanged",
        "list",
        "hasVirtualKBChanged",
        "hasVirtualKB",
        "onUserListSizeChanged",
        "users_size",
        "onHasSwapChanged",
        "hasSwap",
        "canSleepChanged",
        "canSleep",
        "allowShowUserSwitchButtonChanged",
        "allowShowUserSwitchButton",
        "abortConfirmChanged",
        "abortConfirm",
        "userListLoginedChanged",
        "activeAuthChanged",
        "active",
        "blackModeChanged",
        "is_black",
        "HibernateModeChanged",
        "is_hibernate",
        "prepareForSleep",
        "is_Sleep",
        "shutdownInhibit",
        "SessionBaseModel::PowerAction",
        "action",
        "tipsShowed",
        "clearServerLoginWidgetContent",
        "authStateChanged",
        "AuthType",
        "AuthState",
        "authTypeChanged",
        "AuthFlags",
        "hidePluginMenu",
        "terminalLockedChanged",
        "isLocked",
        "addUser",
        "path",
        "user",
        "removeUser",
        "updateCurrentUser",
        "userJson",
        "updateUserList",
        "updateLoginedUserList",
        "updateLimitedInfo",
        "info",
        "updateFrameworkState",
        "state",
        "updateSupportedMixAuthFlags",
        "flags",
        "updateSupportedEncryptionType",
        "updateAuthState",
        "updateFactorsInfo",
        "MFAInfoList",
        "infoList",
        "updateFuzzyMFA",
        "fuzzMFA",
        "updateMFAFlag",
        "MFAFlag",
        "updatePINLen",
        "PINLen",
        "updatePrompt",
        "prompt",
        "Fprint",
        "KEYBOARD",
        "None",
        "RequireNormal",
        "RequireUpdateShutdown",
        "RequireUpdateRestart",
        "RequireShutdown",
        "RequireRestart",
        "RequireSuspend",
        "RequireHibernate",
        "RequireLock",
        "RequireLogout",
        "RequireSwitchUser",
        "RequireSwitchSystem",
        "NoStatus",
        "PasswordMode",
        "ConfirmPasswordMode",
        "UserMode",
        "SessionMode",
        "PowerMode",
        "ShutDownMode",
        "ResetPasswdMode",
        "UpdateMode",
        "SelectSameNameUserMode",
        "UpdatePowerMode",
        "UPM_None",
        "UPM_UpdateAndShutdown",
        "UPM_UpdateAndReboot",
        "ContentType",
        "NoContent",
        "WarningContent",
        "LockContent",
        "UpdateContent"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'currentUserChanged'
        QtMocHelpers::SignalData<void(const std::shared_ptr<User>)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 2 },
        }}),
        // Signal 'userAdded'
        QtMocHelpers::SignalData<void(const std::shared_ptr<User>)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 2 },
        }}),
        // Signal 'userRemoved'
        QtMocHelpers::SignalData<void(const std::shared_ptr<User>)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 2 },
        }}),
        // Signal 'userListChanged'
        QtMocHelpers::SignalData<void(const QList<std::shared_ptr<User>>)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 2 },
        }}),
        // Signal 'loginedUserListChanged'
        QtMocHelpers::SignalData<void(const QList<std::shared_ptr<User>>)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 2 },
        }}),
        // Signal 'MFAFlagChanged'
        QtMocHelpers::SignalData<void(const bool)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'visibleChanged'
        QtMocHelpers::SignalData<void(const bool)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 2 },
        }}),
        // Signal 'lightdmPamStartedChanged'
        QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'authTipsMessage'
        QtMocHelpers::SignalData<void(const QString &, enum AuthFailedType)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 13 }, { 0x80000000 | 14, 15 },
        }}),
        // Signal 'authTipsMessage'
        QtMocHelpers::SignalData<void(const QString &)>(12, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 13 },
        }}),
        // Signal 'authFailedMessage'
        QtMocHelpers::SignalData<void(const QString &, enum AuthFailedType)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 13 }, { 0x80000000 | 14, 15 },
        }}),
        // Signal 'authFailedMessage'
        QtMocHelpers::SignalData<void(const QString &)>(16, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 13 },
        }}),
        // Signal 'authFailedTipsMessage'
        QtMocHelpers::SignalData<void(const QString &, enum AuthFailedType)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 13 }, { 0x80000000 | 14, 15 },
        }}),
        // Signal 'authFailedTipsMessage'
        QtMocHelpers::SignalData<void(const QString &)>(17, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 13 },
        }}),
        // Signal 'authFinished'
        QtMocHelpers::SignalData<void(bool)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 19 },
        }}),
        // Signal 'accountError'
        QtMocHelpers::SignalData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'checkAccountFinished'
        QtMocHelpers::SignalData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'onPowerActionChanged'
        QtMocHelpers::SignalData<void(enum PowerAction)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 24 },
        }}),
        // Signal 'onRequirePowerAction'
        QtMocHelpers::SignalData<void(enum PowerAction, bool)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 23, 24 }, { QMetaType::Bool, 26 },
        }}),
        // Signal 'onSessionKeyChanged'
        QtMocHelpers::SignalData<void(const QString &)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 28 },
        }}),
        // Signal 'showUserList'
        QtMocHelpers::SignalData<void()>(29, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showLockScreen'
        QtMocHelpers::SignalData<void()>(30, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showShutdown'
        QtMocHelpers::SignalData<void()>(31, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showUpdate'
        QtMocHelpers::SignalData<void(bool)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 33 },
        }}),
        // Signal 'onStatusChanged'
        QtMocHelpers::SignalData<void(enum ModeStatus)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 36 },
        }}),
        // Signal 'onUserListChanged'
        QtMocHelpers::SignalData<void(QList<std::shared_ptr<User>>)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 38 },
        }}),
        // Signal 'hasVirtualKBChanged'
        QtMocHelpers::SignalData<void(bool)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 40 },
        }}),
        // Signal 'onUserListSizeChanged'
        QtMocHelpers::SignalData<void(int)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 42 },
        }}),
        // Signal 'onHasSwapChanged'
        QtMocHelpers::SignalData<void(bool)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 44 },
        }}),
        // Signal 'canSleepChanged'
        QtMocHelpers::SignalData<void(bool)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 46 },
        }}),
        // Signal 'allowShowUserSwitchButtonChanged'
        QtMocHelpers::SignalData<void(bool)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 48 },
        }}),
        // Signal 'abortConfirmChanged'
        QtMocHelpers::SignalData<void(bool)>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 50 },
        }}),
        // Signal 'userListLoginedChanged'
        QtMocHelpers::SignalData<void(QList<std::shared_ptr<User>>)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 38 },
        }}),
        // Signal 'activeAuthChanged'
        QtMocHelpers::SignalData<void(bool)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 53 },
        }}),
        // Signal 'blackModeChanged'
        QtMocHelpers::SignalData<void(bool)>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 55 },
        }}),
        // Signal 'HibernateModeChanged'
        QtMocHelpers::SignalData<void(bool)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 57 },
        }}),
        // Signal 'prepareForSleep'
        QtMocHelpers::SignalData<void(bool)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 59 },
        }}),
        // Signal 'shutdownInhibit'
        QtMocHelpers::SignalData<void(const SessionBaseModel::PowerAction, bool)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 61, 62 }, { QMetaType::Bool, 26 },
        }}),
        // Signal 'tipsShowed'
        QtMocHelpers::SignalData<void()>(63, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'clearServerLoginWidgetContent'
        QtMocHelpers::SignalData<void()>(64, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'authStateChanged'
        QtMocHelpers::SignalData<void(const AuthType, const AuthState, const QString &)>(65, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 66, 2 }, { 0x80000000 | 67, 2 }, { QMetaType::QString, 2 },
        }}),
        // Signal 'authTypeChanged'
        QtMocHelpers::SignalData<void(const AuthFlags)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 69, 15 },
        }}),
        // Signal 'hidePluginMenu'
        QtMocHelpers::SignalData<void()>(70, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'terminalLockedChanged'
        QtMocHelpers::SignalData<void(bool)>(71, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 72 },
        }}),
        // Slot 'addUser'
        QtMocHelpers::SlotData<void(const QString &)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 74 },
        }}),
        // Slot 'addUser'
        QtMocHelpers::SlotData<void(const std::shared_ptr<User>)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 75 },
        }}),
        // Slot 'removeUser'
        QtMocHelpers::SlotData<void(const QString &)>(76, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 74 },
        }}),
        // Slot 'removeUser'
        QtMocHelpers::SlotData<void(const std::shared_ptr<User>)>(76, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 75 },
        }}),
        // Slot 'updateCurrentUser'
        QtMocHelpers::SlotData<bool(const QString &)>(77, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 78 },
        }}),
        // Slot 'updateCurrentUser'
        QtMocHelpers::SlotData<bool(const std::shared_ptr<User>)>(77, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 3, 75 },
        }}),
        // Slot 'updateUserList'
        QtMocHelpers::SlotData<void(const QStringList &)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 38 },
        }}),
        // Slot 'updateLoginedUserList'
        QtMocHelpers::SlotData<void(const QString &)>(80, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 38 },
        }}),
        // Slot 'updateLimitedInfo'
        QtMocHelpers::SlotData<void(const QString &)>(81, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 82 },
        }}),
        // Slot 'updateFrameworkState'
        QtMocHelpers::SlotData<void(const int)>(83, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 84 },
        }}),
        // Slot 'updateSupportedMixAuthFlags'
        QtMocHelpers::SlotData<void(const int)>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 86 },
        }}),
        // Slot 'updateSupportedEncryptionType'
        QtMocHelpers::SlotData<void(const QString &)>(87, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 15 },
        }}),
        // Slot 'updateAuthState'
        QtMocHelpers::SlotData<void(const AuthType, const AuthState, const QString &)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 66, 15 }, { 0x80000000 | 67, 84 }, { QMetaType::QString, 13 },
        }}),
        // Slot 'updateFactorsInfo'
        QtMocHelpers::SlotData<void(const MFAInfoList &)>(89, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 90, 91 },
        }}),
        // Slot 'updateFuzzyMFA'
        QtMocHelpers::SlotData<void(const bool)>(92, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 93 },
        }}),
        // Slot 'updateMFAFlag'
        QtMocHelpers::SlotData<void(const bool)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 95 },
        }}),
        // Slot 'updatePINLen'
        QtMocHelpers::SlotData<void(const int)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 97 },
        }}),
        // Slot 'updatePrompt'
        QtMocHelpers::SlotData<void(const QString &)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 99 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'AuthFailedType'
        QtMocHelpers::EnumData<enum AuthFailedType>(14, 14, QMC::EnumFlags{}).add({
            {  100, AuthFailedType::Fprint },
            {  101, AuthFailedType::KEYBOARD },
        }),
        // enum 'PowerAction'
        QtMocHelpers::EnumData<enum PowerAction>(23, 23, QMC::EnumFlags{}).add({
            {  102, PowerAction::None },
            {  103, PowerAction::RequireNormal },
            {  104, PowerAction::RequireUpdateShutdown },
            {  105, PowerAction::RequireUpdateRestart },
            {  106, PowerAction::RequireShutdown },
            {  107, PowerAction::RequireRestart },
            {  108, PowerAction::RequireSuspend },
            {  109, PowerAction::RequireHibernate },
            {  110, PowerAction::RequireLock },
            {  111, PowerAction::RequireLogout },
            {  112, PowerAction::RequireSwitchUser },
            {  113, PowerAction::RequireSwitchSystem },
        }),
        // enum 'ModeStatus'
        QtMocHelpers::EnumData<enum ModeStatus>(35, 35, QMC::EnumFlags{}).add({
            {  114, ModeStatus::NoStatus },
            {  115, ModeStatus::PasswordMode },
            {  116, ModeStatus::ConfirmPasswordMode },
            {  117, ModeStatus::UserMode },
            {  118, ModeStatus::SessionMode },
            {  119, ModeStatus::PowerMode },
            {  120, ModeStatus::ShutDownMode },
            {  121, ModeStatus::ResetPasswdMode },
            {  122, ModeStatus::UpdateMode },
            {  123, ModeStatus::SelectSameNameUserMode },
        }),
        // enum 'UpdatePowerMode'
        QtMocHelpers::EnumData<enum UpdatePowerMode>(124, 124, QMC::EnumFlags{}).add({
            {  125, UpdatePowerMode::UPM_None },
            {  126, UpdatePowerMode::UPM_UpdateAndShutdown },
            {  127, UpdatePowerMode::UPM_UpdateAndReboot },
        }),
        // enum 'ContentType'
        QtMocHelpers::EnumData<enum ContentType>(128, 128, QMC::EnumFlags{}).add({
            {  129, ContentType::NoContent },
            {  130, ContentType::WarningContent },
            {  131, ContentType::LockContent },
            {  132, ContentType::UpdateContent },
        }),
    };
    return QtMocHelpers::metaObjectData<SessionBaseModel, qt_meta_tag_ZN16SessionBaseModelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject SessionBaseModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16SessionBaseModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16SessionBaseModelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16SessionBaseModelE_t>.metaTypes,
    nullptr
} };

void SessionBaseModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<SessionBaseModel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->currentUserChanged((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<User>>>(_a[1]))); break;
        case 1: _t->userAdded((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<User>>>(_a[1]))); break;
        case 2: _t->userRemoved((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<User>>>(_a[1]))); break;
        case 3: _t->userListChanged((*reinterpret_cast<std::add_pointer_t<QList<std::shared_ptr<User>>>>(_a[1]))); break;
        case 4: _t->loginedUserListChanged((*reinterpret_cast<std::add_pointer_t<QList<std::shared_ptr<User>>>>(_a[1]))); break;
        case 5: _t->MFAFlagChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 6: _t->visibleChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->lightdmPamStartedChanged(); break;
        case 8: _t->authTipsMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<enum AuthFailedType>>(_a[2]))); break;
        case 9: _t->authTipsMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 10: _t->authFailedMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<enum AuthFailedType>>(_a[2]))); break;
        case 11: _t->authFailedMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 12: _t->authFailedTipsMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<enum AuthFailedType>>(_a[2]))); break;
        case 13: _t->authFailedTipsMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 14: _t->authFinished((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 15: _t->accountError(); break;
        case 16: _t->checkAccountFinished(); break;
        case 17: _t->onPowerActionChanged((*reinterpret_cast<std::add_pointer_t<enum PowerAction>>(_a[1]))); break;
        case 18: _t->onRequirePowerAction((*reinterpret_cast<std::add_pointer_t<enum PowerAction>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 19: _t->onSessionKeyChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 20: _t->showUserList(); break;
        case 21: _t->showLockScreen(); break;
        case 22: _t->showShutdown(); break;
        case 23: _t->showUpdate((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 24: _t->onStatusChanged((*reinterpret_cast<std::add_pointer_t<enum ModeStatus>>(_a[1]))); break;
        case 25: _t->onUserListChanged((*reinterpret_cast<std::add_pointer_t<QList<std::shared_ptr<User>>>>(_a[1]))); break;
        case 26: _t->hasVirtualKBChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 27: _t->onUserListSizeChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 28: _t->onHasSwapChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 29: _t->canSleepChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 30: _t->allowShowUserSwitchButtonChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 31: _t->abortConfirmChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 32: _t->userListLoginedChanged((*reinterpret_cast<std::add_pointer_t<QList<std::shared_ptr<User>>>>(_a[1]))); break;
        case 33: _t->activeAuthChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 34: _t->blackModeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 35: _t->HibernateModeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 36: _t->prepareForSleep((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 37: _t->shutdownInhibit((*reinterpret_cast<std::add_pointer_t<SessionBaseModel::PowerAction>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 38: _t->tipsShowed(); break;
        case 39: _t->clearServerLoginWidgetContent(); break;
        case 40: _t->authStateChanged((*reinterpret_cast<std::add_pointer_t<AuthType>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<AuthState>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 41: _t->authTypeChanged((*reinterpret_cast<std::add_pointer_t<AuthFlags>>(_a[1]))); break;
        case 42: _t->hidePluginMenu(); break;
        case 43: _t->terminalLockedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 44: _t->addUser((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 45: _t->addUser((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<User>>>(_a[1]))); break;
        case 46: _t->removeUser((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 47: _t->removeUser((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<User>>>(_a[1]))); break;
        case 48: { bool _r = _t->updateCurrentUser((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 49: { bool _r = _t->updateCurrentUser((*reinterpret_cast<std::add_pointer_t<std::shared_ptr<User>>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 50: _t->updateUserList((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 51: _t->updateLoginedUserList((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 52: _t->updateLimitedInfo((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 53: _t->updateFrameworkState((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 54: _t->updateSupportedMixAuthFlags((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 55: _t->updateSupportedEncryptionType((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 56: _t->updateAuthState((*reinterpret_cast<std::add_pointer_t<AuthType>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<AuthState>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 57: _t->updateFactorsInfo((*reinterpret_cast<std::add_pointer_t<MFAInfoList>>(_a[1]))); break;
        case 58: _t->updateFuzzyMFA((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 59: _t->updateMFAFlag((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 60: _t->updatePINLen((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 61: _t->updatePrompt((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 57:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< MFAInfoList >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const std::shared_ptr<User> )>(_a, &SessionBaseModel::currentUserChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const std::shared_ptr<User> )>(_a, &SessionBaseModel::userAdded, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const std::shared_ptr<User> )>(_a, &SessionBaseModel::userRemoved, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const QList<std::shared_ptr<User>> )>(_a, &SessionBaseModel::userListChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const QList<std::shared_ptr<User>> )>(_a, &SessionBaseModel::loginedUserListChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const bool )>(_a, &SessionBaseModel::MFAFlagChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const bool )>(_a, &SessionBaseModel::visibleChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)()>(_a, &SessionBaseModel::lightdmPamStartedChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const QString & , AuthFailedType )>(_a, &SessionBaseModel::authTipsMessage, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const QString & , AuthFailedType )>(_a, &SessionBaseModel::authFailedMessage, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const QString & , AuthFailedType )>(_a, &SessionBaseModel::authFailedTipsMessage, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(bool )>(_a, &SessionBaseModel::authFinished, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)()>(_a, &SessionBaseModel::accountError, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)()>(_a, &SessionBaseModel::checkAccountFinished, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(PowerAction )>(_a, &SessionBaseModel::onPowerActionChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(PowerAction , bool )>(_a, &SessionBaseModel::onRequirePowerAction, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const QString & )>(_a, &SessionBaseModel::onSessionKeyChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)()>(_a, &SessionBaseModel::showUserList, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)()>(_a, &SessionBaseModel::showLockScreen, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)()>(_a, &SessionBaseModel::showShutdown, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(bool )>(_a, &SessionBaseModel::showUpdate, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(ModeStatus )>(_a, &SessionBaseModel::onStatusChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(QList<std::shared_ptr<User>> )>(_a, &SessionBaseModel::onUserListChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(bool )>(_a, &SessionBaseModel::hasVirtualKBChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(int )>(_a, &SessionBaseModel::onUserListSizeChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(bool )>(_a, &SessionBaseModel::onHasSwapChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(bool )>(_a, &SessionBaseModel::canSleepChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(bool )>(_a, &SessionBaseModel::allowShowUserSwitchButtonChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(bool )>(_a, &SessionBaseModel::abortConfirmChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(QList<std::shared_ptr<User>> )>(_a, &SessionBaseModel::userListLoginedChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(bool )>(_a, &SessionBaseModel::activeAuthChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(bool )>(_a, &SessionBaseModel::blackModeChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(bool )>(_a, &SessionBaseModel::HibernateModeChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(bool )>(_a, &SessionBaseModel::prepareForSleep, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const SessionBaseModel::PowerAction , bool )>(_a, &SessionBaseModel::shutdownInhibit, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)()>(_a, &SessionBaseModel::tipsShowed, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)()>(_a, &SessionBaseModel::clearServerLoginWidgetContent, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const AuthType , const AuthState , const QString & )>(_a, &SessionBaseModel::authStateChanged, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(const AuthFlags )>(_a, &SessionBaseModel::authTypeChanged, 41))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)()>(_a, &SessionBaseModel::hidePluginMenu, 42))
            return;
        if (QtMocHelpers::indexOfMethod<void (SessionBaseModel::*)(bool )>(_a, &SessionBaseModel::terminalLockedChanged, 43))
            return;
    }
}

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

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

int SessionBaseModel::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 < 62)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 62;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 62)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 62;
    }
    return _id;
}

// SIGNAL 0
void SessionBaseModel::currentUserChanged(const std::shared_ptr<User> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void SessionBaseModel::userAdded(const std::shared_ptr<User> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void SessionBaseModel::userRemoved(const std::shared_ptr<User> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void SessionBaseModel::userListChanged(const QList<std::shared_ptr<User>> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void SessionBaseModel::loginedUserListChanged(const QList<std::shared_ptr<User>> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void SessionBaseModel::MFAFlagChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void SessionBaseModel::visibleChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void SessionBaseModel::lightdmPamStartedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void SessionBaseModel::authTipsMessage(const QString & _t1, AuthFailedType _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1, _t2);
}

// SIGNAL 10
void SessionBaseModel::authFailedMessage(const QString & _t1, AuthFailedType _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1, _t2);
}

// SIGNAL 12
void SessionBaseModel::authFailedTipsMessage(const QString & _t1, AuthFailedType _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1, _t2);
}

// SIGNAL 14
void SessionBaseModel::authFinished(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void SessionBaseModel::accountError()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void SessionBaseModel::checkAccountFinished()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void SessionBaseModel::onPowerActionChanged(PowerAction _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void SessionBaseModel::onRequirePowerAction(PowerAction _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1, _t2);
}

// SIGNAL 19
void SessionBaseModel::onSessionKeyChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void SessionBaseModel::showUserList()
{
    QMetaObject::activate(this, &staticMetaObject, 20, nullptr);
}

// SIGNAL 21
void SessionBaseModel::showLockScreen()
{
    QMetaObject::activate(this, &staticMetaObject, 21, nullptr);
}

// SIGNAL 22
void SessionBaseModel::showShutdown()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}

// SIGNAL 23
void SessionBaseModel::showUpdate(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void SessionBaseModel::onStatusChanged(ModeStatus _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void SessionBaseModel::onUserListChanged(QList<std::shared_ptr<User>> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void SessionBaseModel::hasVirtualKBChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void SessionBaseModel::onUserListSizeChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1);
}

// SIGNAL 28
void SessionBaseModel::onHasSwapChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void SessionBaseModel::canSleepChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1);
}

// SIGNAL 30
void SessionBaseModel::allowShowUserSwitchButtonChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1);
}

// SIGNAL 31
void SessionBaseModel::abortConfirmChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1);
}

// SIGNAL 32
void SessionBaseModel::userListLoginedChanged(QList<std::shared_ptr<User>> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 32, nullptr, _t1);
}

// SIGNAL 33
void SessionBaseModel::activeAuthChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 33, nullptr, _t1);
}

// SIGNAL 34
void SessionBaseModel::blackModeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1);
}

// SIGNAL 35
void SessionBaseModel::HibernateModeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 35, nullptr, _t1);
}

// SIGNAL 36
void SessionBaseModel::prepareForSleep(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 36, nullptr, _t1);
}

// SIGNAL 37
void SessionBaseModel::shutdownInhibit(const SessionBaseModel::PowerAction _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 37, nullptr, _t1, _t2);
}

// SIGNAL 38
void SessionBaseModel::tipsShowed()
{
    QMetaObject::activate(this, &staticMetaObject, 38, nullptr);
}

// SIGNAL 39
void SessionBaseModel::clearServerLoginWidgetContent()
{
    QMetaObject::activate(this, &staticMetaObject, 39, nullptr);
}

// SIGNAL 40
void SessionBaseModel::authStateChanged(const AuthType _t1, const AuthState _t2, const QString & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 40, nullptr, _t1, _t2, _t3);
}

// SIGNAL 41
void SessionBaseModel::authTypeChanged(const AuthFlags _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 41, nullptr, _t1);
}

// SIGNAL 42
void SessionBaseModel::hidePluginMenu()
{
    QMetaObject::activate(this, &staticMetaObject, 42, nullptr);
}

// SIGNAL 43
void SessionBaseModel::terminalLockedChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 43, nullptr, _t1);
}
QT_WARNING_POP
