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

#include <memory>
#include "../../src/session-widgets/sessionbasemodel.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#include <QtCore/QList>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'sessionbasemodel.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.15.18. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

QT_BEGIN_MOC_NAMESPACE
QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
struct qt_meta_stringdata_SessionBaseModel_t {
    QByteArrayData data[114];
    char stringdata0[1644];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
    Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
    qptrdiff(offsetof(qt_meta_stringdata_SessionBaseModel_t, stringdata0) + ofs \
        - idx * sizeof(QByteArrayData)) \
    )
static const qt_meta_stringdata_SessionBaseModel_t qt_meta_stringdata_SessionBaseModel = {
    {
QT_MOC_LITERAL(0, 0, 16), // "SessionBaseModel"
QT_MOC_LITERAL(1, 17, 18), // "currentUserChanged"
QT_MOC_LITERAL(2, 36, 0), // ""
QT_MOC_LITERAL(3, 37, 21), // "std::shared_ptr<User>"
QT_MOC_LITERAL(4, 59, 9), // "userAdded"
QT_MOC_LITERAL(5, 69, 11), // "userRemoved"
QT_MOC_LITERAL(6, 81, 15), // "userListChanged"
QT_MOC_LITERAL(7, 97, 29), // "QList<std::shared_ptr<User> >"
QT_MOC_LITERAL(8, 127, 22), // "loginedUserListChanged"
QT_MOC_LITERAL(9, 150, 14), // "MFAFlagChanged"
QT_MOC_LITERAL(10, 165, 14), // "visibleChanged"
QT_MOC_LITERAL(11, 180, 15), // "authTipsMessage"
QT_MOC_LITERAL(12, 196, 7), // "message"
QT_MOC_LITERAL(13, 204, 14), // "AuthFailedType"
QT_MOC_LITERAL(14, 219, 4), // "type"
QT_MOC_LITERAL(15, 224, 17), // "authFailedMessage"
QT_MOC_LITERAL(16, 242, 21), // "authFailedTipsMessage"
QT_MOC_LITERAL(17, 264, 12), // "authFinished"
QT_MOC_LITERAL(18, 277, 7), // "success"
QT_MOC_LITERAL(19, 285, 20), // "onPowerActionChanged"
QT_MOC_LITERAL(20, 306, 11), // "PowerAction"
QT_MOC_LITERAL(21, 318, 11), // "poweraction"
QT_MOC_LITERAL(22, 330, 20), // "onRequirePowerAction"
QT_MOC_LITERAL(23, 351, 11), // "needConfirm"
QT_MOC_LITERAL(24, 363, 19), // "onSessionKeyChanged"
QT_MOC_LITERAL(25, 383, 10), // "sessionKey"
QT_MOC_LITERAL(26, 394, 12), // "showUserList"
QT_MOC_LITERAL(27, 407, 14), // "showLockScreen"
QT_MOC_LITERAL(28, 422, 12), // "showShutdown"
QT_MOC_LITERAL(29, 435, 15), // "onStatusChanged"
QT_MOC_LITERAL(30, 451, 10), // "ModeStatus"
QT_MOC_LITERAL(31, 462, 6), // "status"
QT_MOC_LITERAL(32, 469, 17), // "onUserListChanged"
QT_MOC_LITERAL(33, 487, 4), // "list"
QT_MOC_LITERAL(34, 492, 19), // "hasVirtualKBChanged"
QT_MOC_LITERAL(35, 512, 12), // "hasVirtualKB"
QT_MOC_LITERAL(36, 525, 21), // "onUserListSizeChanged"
QT_MOC_LITERAL(37, 547, 10), // "users_size"
QT_MOC_LITERAL(38, 558, 16), // "onHasSwapChanged"
QT_MOC_LITERAL(39, 575, 7), // "hasSwap"
QT_MOC_LITERAL(40, 583, 15), // "canSleepChanged"
QT_MOC_LITERAL(41, 599, 8), // "canSleep"
QT_MOC_LITERAL(42, 608, 32), // "allowShowUserSwitchButtonChanged"
QT_MOC_LITERAL(43, 641, 25), // "allowShowUserSwitchButton"
QT_MOC_LITERAL(44, 667, 19), // "abortConfirmChanged"
QT_MOC_LITERAL(45, 687, 12), // "abortConfirm"
QT_MOC_LITERAL(46, 700, 22), // "userListLoginedChanged"
QT_MOC_LITERAL(47, 723, 17), // "activeAuthChanged"
QT_MOC_LITERAL(48, 741, 6), // "active"
QT_MOC_LITERAL(49, 748, 16), // "blackModeChanged"
QT_MOC_LITERAL(50, 765, 8), // "is_black"
QT_MOC_LITERAL(51, 774, 20), // "HibernateModeChanged"
QT_MOC_LITERAL(52, 795, 12), // "is_hibernate"
QT_MOC_LITERAL(53, 808, 15), // "prepareForSleep"
QT_MOC_LITERAL(54, 824, 8), // "is_Sleep"
QT_MOC_LITERAL(55, 833, 15), // "shutdownInhibit"
QT_MOC_LITERAL(56, 849, 29), // "SessionBaseModel::PowerAction"
QT_MOC_LITERAL(57, 879, 6), // "action"
QT_MOC_LITERAL(58, 886, 21), // "cancelShutdownInhibit"
QT_MOC_LITERAL(59, 908, 9), // "hideFrame"
QT_MOC_LITERAL(60, 918, 17), // "requestLoginFrame"
QT_MOC_LITERAL(61, 936, 29), // "clearServerLoginWidgetContent"
QT_MOC_LITERAL(62, 966, 16), // "authStateChanged"
QT_MOC_LITERAL(63, 983, 15), // "authTypeChanged"
QT_MOC_LITERAL(64, 999, 7), // "addUser"
QT_MOC_LITERAL(65, 1007, 4), // "path"
QT_MOC_LITERAL(66, 1012, 4), // "user"
QT_MOC_LITERAL(67, 1017, 10), // "removeUser"
QT_MOC_LITERAL(68, 1028, 17), // "updateCurrentUser"
QT_MOC_LITERAL(69, 1046, 8), // "userJson"
QT_MOC_LITERAL(70, 1055, 14), // "updateUserList"
QT_MOC_LITERAL(71, 1070, 20), // "updateLastLogoutUser"
QT_MOC_LITERAL(72, 1091, 5), // "uid_t"
QT_MOC_LITERAL(73, 1097, 3), // "uid"
QT_MOC_LITERAL(74, 1101, 14), // "lastLogoutUser"
QT_MOC_LITERAL(75, 1116, 21), // "updateLoginedUserList"
QT_MOC_LITERAL(76, 1138, 17), // "updateLimitedInfo"
QT_MOC_LITERAL(77, 1156, 4), // "info"
QT_MOC_LITERAL(78, 1161, 20), // "updateFrameworkState"
QT_MOC_LITERAL(79, 1182, 5), // "state"
QT_MOC_LITERAL(80, 1188, 27), // "updateSupportedMixAuthFlags"
QT_MOC_LITERAL(81, 1216, 5), // "flags"
QT_MOC_LITERAL(82, 1222, 29), // "updateSupportedEncryptionType"
QT_MOC_LITERAL(83, 1252, 15), // "updateAuthState"
QT_MOC_LITERAL(84, 1268, 17), // "updateFactorsInfo"
QT_MOC_LITERAL(85, 1286, 11), // "MFAInfoList"
QT_MOC_LITERAL(86, 1298, 8), // "infoList"
QT_MOC_LITERAL(87, 1307, 14), // "updateFuzzyMFA"
QT_MOC_LITERAL(88, 1322, 7), // "fuzzMFA"
QT_MOC_LITERAL(89, 1330, 13), // "updateMFAFlag"
QT_MOC_LITERAL(90, 1344, 7), // "MFAFlag"
QT_MOC_LITERAL(91, 1352, 12), // "updatePINLen"
QT_MOC_LITERAL(92, 1365, 6), // "PINLen"
QT_MOC_LITERAL(93, 1372, 12), // "updatePrompt"
QT_MOC_LITERAL(94, 1385, 6), // "prompt"
QT_MOC_LITERAL(95, 1392, 6), // "Fprint"
QT_MOC_LITERAL(96, 1399, 8), // "KEYBOARD"
QT_MOC_LITERAL(97, 1408, 4), // "None"
QT_MOC_LITERAL(98, 1413, 13), // "RequireNormal"
QT_MOC_LITERAL(99, 1427, 15), // "RequireShutdown"
QT_MOC_LITERAL(100, 1443, 14), // "RequireRestart"
QT_MOC_LITERAL(101, 1458, 14), // "RequireSuspend"
QT_MOC_LITERAL(102, 1473, 16), // "RequireHibernate"
QT_MOC_LITERAL(103, 1490, 11), // "RequireLock"
QT_MOC_LITERAL(104, 1502, 13), // "RequireLogout"
QT_MOC_LITERAL(105, 1516, 17), // "RequireSwitchUser"
QT_MOC_LITERAL(106, 1534, 19), // "RequireSwitchSystem"
QT_MOC_LITERAL(107, 1554, 8), // "NoStatus"
QT_MOC_LITERAL(108, 1563, 12), // "PasswordMode"
QT_MOC_LITERAL(109, 1576, 19), // "ConfirmPasswordMode"
QT_MOC_LITERAL(110, 1596, 8), // "UserMode"
QT_MOC_LITERAL(111, 1605, 9), // "PowerMode"
QT_MOC_LITERAL(112, 1615, 12), // "ShutDownMode"
QT_MOC_LITERAL(113, 1628, 15) // "ResetPasswdMode"

    },
    "SessionBaseModel\0currentUserChanged\0"
    "\0std::shared_ptr<User>\0userAdded\0"
    "userRemoved\0userListChanged\0"
    "QList<std::shared_ptr<User> >\0"
    "loginedUserListChanged\0MFAFlagChanged\0"
    "visibleChanged\0authTipsMessage\0message\0"
    "AuthFailedType\0type\0authFailedMessage\0"
    "authFailedTipsMessage\0authFinished\0"
    "success\0onPowerActionChanged\0PowerAction\0"
    "poweraction\0onRequirePowerAction\0"
    "needConfirm\0onSessionKeyChanged\0"
    "sessionKey\0showUserList\0showLockScreen\0"
    "showShutdown\0onStatusChanged\0ModeStatus\0"
    "status\0onUserListChanged\0list\0"
    "hasVirtualKBChanged\0hasVirtualKB\0"
    "onUserListSizeChanged\0users_size\0"
    "onHasSwapChanged\0hasSwap\0canSleepChanged\0"
    "canSleep\0allowShowUserSwitchButtonChanged\0"
    "allowShowUserSwitchButton\0abortConfirmChanged\0"
    "abortConfirm\0userListLoginedChanged\0"
    "activeAuthChanged\0active\0blackModeChanged\0"
    "is_black\0HibernateModeChanged\0"
    "is_hibernate\0prepareForSleep\0is_Sleep\0"
    "shutdownInhibit\0SessionBaseModel::PowerAction\0"
    "action\0cancelShutdownInhibit\0hideFrame\0"
    "requestLoginFrame\0clearServerLoginWidgetContent\0"
    "authStateChanged\0authTypeChanged\0"
    "addUser\0path\0user\0removeUser\0"
    "updateCurrentUser\0userJson\0updateUserList\0"
    "updateLastLogoutUser\0uid_t\0uid\0"
    "lastLogoutUser\0updateLoginedUserList\0"
    "updateLimitedInfo\0info\0updateFrameworkState\0"
    "state\0updateSupportedMixAuthFlags\0"
    "flags\0updateSupportedEncryptionType\0"
    "updateAuthState\0updateFactorsInfo\0"
    "MFAInfoList\0infoList\0updateFuzzyMFA\0"
    "fuzzMFA\0updateMFAFlag\0MFAFlag\0"
    "updatePINLen\0PINLen\0updatePrompt\0"
    "prompt\0Fprint\0KEYBOARD\0None\0RequireNormal\0"
    "RequireShutdown\0RequireRestart\0"
    "RequireSuspend\0RequireHibernate\0"
    "RequireLock\0RequireLogout\0RequireSwitchUser\0"
    "RequireSwitchSystem\0NoStatus\0PasswordMode\0"
    "ConfirmPasswordMode\0UserMode\0PowerMode\0"
    "ShutDownMode\0ResetPasswdMode"
};
#undef QT_MOC_LITERAL

static const uint qt_meta_data_SessionBaseModel[] = {

 // content:
       8,       // revision
       0,       // classname
       0,    0, // classinfo
      59,   14, // methods
       0,    0, // properties
       3,  494, // enums/sets
       0,    0, // constructors
       0,       // flags
      39,       // signalCount

 // signals: name, argc, parameters, tag, flags
       1,    1,  309,    2, 0x06 /* Public */,
       4,    1,  312,    2, 0x06 /* Public */,
       5,    1,  315,    2, 0x06 /* Public */,
       6,    1,  318,    2, 0x06 /* Public */,
       8,    1,  321,    2, 0x06 /* Public */,
       9,    1,  324,    2, 0x06 /* Public */,
      10,    1,  327,    2, 0x06 /* Public */,
      11,    2,  330,    2, 0x06 /* Public */,
      11,    1,  335,    2, 0x26 /* Public | MethodCloned */,
      15,    2,  338,    2, 0x06 /* Public */,
      15,    1,  343,    2, 0x26 /* Public | MethodCloned */,
      16,    2,  346,    2, 0x06 /* Public */,
      16,    1,  351,    2, 0x26 /* Public | MethodCloned */,
      17,    1,  354,    2, 0x06 /* Public */,
      19,    1,  357,    2, 0x06 /* Public */,
      22,    2,  360,    2, 0x06 /* Public */,
      24,    1,  365,    2, 0x06 /* Public */,
      26,    0,  368,    2, 0x06 /* Public */,
      27,    0,  369,    2, 0x06 /* Public */,
      28,    0,  370,    2, 0x06 /* Public */,
      29,    1,  371,    2, 0x06 /* Public */,
      32,    1,  374,    2, 0x06 /* Public */,
      34,    1,  377,    2, 0x06 /* Public */,
      36,    1,  380,    2, 0x06 /* Public */,
      38,    1,  383,    2, 0x06 /* Public */,
      40,    1,  386,    2, 0x06 /* Public */,
      42,    1,  389,    2, 0x06 /* Public */,
      44,    1,  392,    2, 0x06 /* Public */,
      46,    1,  395,    2, 0x06 /* Public */,
      47,    1,  398,    2, 0x06 /* Public */,
      49,    1,  401,    2, 0x06 /* Public */,
      51,    1,  404,    2, 0x06 /* Public */,
      53,    1,  407,    2, 0x06 /* Public */,
      55,    2,  410,    2, 0x06 /* Public */,
      58,    1,  415,    2, 0x06 /* Public */,
      60,    0,  418,    2, 0x06 /* Public */,
      61,    0,  419,    2, 0x06 /* Public */,
      62,    3,  420,    2, 0x06 /* Public */,
      63,    1,  427,    2, 0x06 /* Public */,

 // slots: name, argc, parameters, tag, flags
      64,    1,  430,    2, 0x0a /* Public */,
      64,    1,  433,    2, 0x0a /* Public */,
      67,    1,  436,    2, 0x0a /* Public */,
      67,    1,  439,    2, 0x0a /* Public */,
      68,    1,  442,    2, 0x0a /* Public */,
      68,    1,  445,    2, 0x0a /* Public */,
      70,    1,  448,    2, 0x0a /* Public */,
      71,    1,  451,    2, 0x0a /* Public */,
      71,    1,  454,    2, 0x0a /* Public */,
      75,    1,  457,    2, 0x0a /* Public */,
      76,    1,  460,    2, 0x0a /* Public */,
      78,    1,  463,    2, 0x0a /* Public */,
      80,    1,  466,    2, 0x0a /* Public */,
      82,    1,  469,    2, 0x0a /* Public */,
      83,    3,  472,    2, 0x0a /* Public */,
      84,    1,  479,    2, 0x0a /* Public */,
      87,    1,  482,    2, 0x0a /* Public */,
      89,    1,  485,    2, 0x0a /* Public */,
      91,    1,  488,    2, 0x0a /* Public */,
      93,    1,  491,    2, 0x0a /* Public */,

 // signals: parameters
    QMetaType::Void, 0x80000000 | 3,    2,
    QMetaType::Void, 0x80000000 | 3,    2,
    QMetaType::Void, 0x80000000 | 3,    2,
    QMetaType::Void, 0x80000000 | 7,    2,
    QMetaType::Void, 0x80000000 | 7,    2,
    QMetaType::Void, QMetaType::Bool,    2,
    QMetaType::Void, QMetaType::Bool,    2,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 13,   12,   14,
    QMetaType::Void, QMetaType::QString,   12,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 13,   12,   14,
    QMetaType::Void, QMetaType::QString,   12,
    QMetaType::Void, QMetaType::QString, 0x80000000 | 13,   12,   14,
    QMetaType::Void, QMetaType::QString,   12,
    QMetaType::Void, QMetaType::Bool,   18,
    QMetaType::Void, 0x80000000 | 20,   21,
    QMetaType::Void, 0x80000000 | 20, QMetaType::Bool,   21,   23,
    QMetaType::Void, QMetaType::QString,   25,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, 0x80000000 | 30,   31,
    QMetaType::Void, 0x80000000 | 7,   33,
    QMetaType::Void, QMetaType::Bool,   35,
    QMetaType::Void, QMetaType::Int,   37,
    QMetaType::Void, QMetaType::Bool,   39,
    QMetaType::Void, QMetaType::Bool,   41,
    QMetaType::Void, QMetaType::Bool,   43,
    QMetaType::Void, QMetaType::Bool,   45,
    QMetaType::Void, 0x80000000 | 7,   33,
    QMetaType::Void, QMetaType::Bool,   48,
    QMetaType::Void, QMetaType::Bool,   50,
    QMetaType::Void, QMetaType::Bool,   52,
    QMetaType::Void, QMetaType::Bool,   54,
    QMetaType::Void, 0x80000000 | 56, QMetaType::Bool,   57,   23,
    QMetaType::Void, QMetaType::Bool,   59,
    QMetaType::Void,
    QMetaType::Void,
    QMetaType::Void, QMetaType::Int, QMetaType::Int, QMetaType::QString,    2,    2,    2,
    QMetaType::Void, QMetaType::Int,   14,

 // slots: parameters
    QMetaType::Void, QMetaType::QString,   65,
    QMetaType::Void, 0x80000000 | 3,   66,
    QMetaType::Void, QMetaType::QString,   65,
    QMetaType::Void, 0x80000000 | 3,   66,
    QMetaType::Bool, QMetaType::QString,   69,
    QMetaType::Bool, 0x80000000 | 3,   66,
    QMetaType::Void, QMetaType::QStringList,   33,
    QMetaType::Void, 0x80000000 | 72,   73,
    QMetaType::Void, 0x80000000 | 3,   74,
    QMetaType::Void, QMetaType::QString,   33,
    QMetaType::Void, QMetaType::QString,   77,
    QMetaType::Void, QMetaType::Int,   79,
    QMetaType::Void, QMetaType::Int,   81,
    QMetaType::Void, QMetaType::QString,   14,
    QMetaType::Void, QMetaType::Int, QMetaType::Int, QMetaType::QString,   14,   79,   12,
    QMetaType::Void, 0x80000000 | 85,   86,
    QMetaType::Void, QMetaType::Bool,   88,
    QMetaType::Void, QMetaType::Bool,   90,
    QMetaType::Void, QMetaType::Int,   92,
    QMetaType::Void, QMetaType::QString,   94,

 // enums: name, alias, flags, count, data
      13,   13, 0x0,    2,  509,
      20,   20, 0x0,   10,  513,
      30,   30, 0x0,    7,  533,

 // enum data: key, value
      95, uint(SessionBaseModel::Fprint),
      96, uint(SessionBaseModel::KEYBOARD),
      97, uint(SessionBaseModel::None),
      98, uint(SessionBaseModel::RequireNormal),
      99, uint(SessionBaseModel::RequireShutdown),
     100, uint(SessionBaseModel::RequireRestart),
     101, uint(SessionBaseModel::RequireSuspend),
     102, uint(SessionBaseModel::RequireHibernate),
     103, uint(SessionBaseModel::RequireLock),
     104, uint(SessionBaseModel::RequireLogout),
     105, uint(SessionBaseModel::RequireSwitchUser),
     106, uint(SessionBaseModel::RequireSwitchSystem),
     107, uint(SessionBaseModel::NoStatus),
     108, uint(SessionBaseModel::PasswordMode),
     109, uint(SessionBaseModel::ConfirmPasswordMode),
     110, uint(SessionBaseModel::UserMode),
     111, uint(SessionBaseModel::PowerMode),
     112, uint(SessionBaseModel::ShutDownMode),
     113, uint(SessionBaseModel::ResetPasswdMode),

       0        // eod
};

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

QT_INIT_METAOBJECT const QMetaObject SessionBaseModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_meta_stringdata_SessionBaseModel.data,
    qt_meta_data_SessionBaseModel,
    qt_static_metacall,
    nullptr,
    nullptr
} };


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_meta_stringdata_SessionBaseModel.stringdata0))
        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 < 59)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 59;
    } else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 59)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 59;
    }
    return _id;
}

// SIGNAL 0
void SessionBaseModel::currentUserChanged(const std::shared_ptr<User> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 0, _a);
}

// SIGNAL 1
void SessionBaseModel::userAdded(const std::shared_ptr<User> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 1, _a);
}

// SIGNAL 2
void SessionBaseModel::userRemoved(const std::shared_ptr<User> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 2, _a);
}

// SIGNAL 3
void SessionBaseModel::userListChanged(const QList<std::shared_ptr<User>> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 3, _a);
}

// SIGNAL 4
void SessionBaseModel::loginedUserListChanged(const QList<std::shared_ptr<User>> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 4, _a);
}

// SIGNAL 5
void SessionBaseModel::MFAFlagChanged(const bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 5, _a);
}

// SIGNAL 6
void SessionBaseModel::visibleChanged(const bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 6, _a);
}

// SIGNAL 7
void SessionBaseModel::authTipsMessage(const QString & _t1, AuthFailedType _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 7, _a);
}

// SIGNAL 9
void SessionBaseModel::authFailedMessage(const QString & _t1, AuthFailedType _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 9, _a);
}

// SIGNAL 11
void SessionBaseModel::authFailedTipsMessage(const QString & _t1, AuthFailedType _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 11, _a);
}

// SIGNAL 13
void SessionBaseModel::authFinished(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 13, _a);
}

// SIGNAL 14
void SessionBaseModel::onPowerActionChanged(PowerAction _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 14, _a);
}

// SIGNAL 15
void SessionBaseModel::onRequirePowerAction(PowerAction _t1, bool _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 15, _a);
}

// SIGNAL 16
void SessionBaseModel::onSessionKeyChanged(const QString & _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 16, _a);
}

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

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

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

// SIGNAL 20
void SessionBaseModel::onStatusChanged(ModeStatus _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 20, _a);
}

// SIGNAL 21
void SessionBaseModel::onUserListChanged(QList<std::shared_ptr<User>> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 21, _a);
}

// SIGNAL 22
void SessionBaseModel::hasVirtualKBChanged(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 22, _a);
}

// SIGNAL 23
void SessionBaseModel::onUserListSizeChanged(int _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 23, _a);
}

// SIGNAL 24
void SessionBaseModel::onHasSwapChanged(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 24, _a);
}

// SIGNAL 25
void SessionBaseModel::canSleepChanged(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 25, _a);
}

// SIGNAL 26
void SessionBaseModel::allowShowUserSwitchButtonChanged(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 26, _a);
}

// SIGNAL 27
void SessionBaseModel::abortConfirmChanged(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 27, _a);
}

// SIGNAL 28
void SessionBaseModel::userListLoginedChanged(QList<std::shared_ptr<User>> _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 28, _a);
}

// SIGNAL 29
void SessionBaseModel::activeAuthChanged(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 29, _a);
}

// SIGNAL 30
void SessionBaseModel::blackModeChanged(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 30, _a);
}

// SIGNAL 31
void SessionBaseModel::HibernateModeChanged(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 31, _a);
}

// SIGNAL 32
void SessionBaseModel::prepareForSleep(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 32, _a);
}

// SIGNAL 33
void SessionBaseModel::shutdownInhibit(const SessionBaseModel::PowerAction _t1, bool _t2)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))) };
    QMetaObject::activate(this, &staticMetaObject, 33, _a);
}

// SIGNAL 34
void SessionBaseModel::cancelShutdownInhibit(bool _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 34, _a);
}

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

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

// SIGNAL 37
void SessionBaseModel::authStateChanged(const int _t1, const int _t2, const QString & _t3)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t2))), const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t3))) };
    QMetaObject::activate(this, &staticMetaObject, 37, _a);
}

// SIGNAL 38
void SessionBaseModel::authTypeChanged(const int _t1)
{
    void *_a[] = { nullptr, const_cast<void*>(reinterpret_cast<const void*>(std::addressof(_t1))) };
    QMetaObject::activate(this, &staticMetaObject, 38, _a);
}
QT_WARNING_POP
QT_END_MOC_NAMESPACE
