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

#include "../../../../../nextcloud-client/src/gui/tray/usermodel.h"
#include <QtNetwork/QSslError>
#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 'usermodel.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. 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_ZN3OCC14TrayFolderInfoE_t {};
} // unnamed namespace

template <> constexpr inline auto OCC::TrayFolderInfo::qt_create_metaobjectdata<qt_meta_tag_ZN3OCC14TrayFolderInfoE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "OCC::TrayFolderInfo",
        "name",
        "parentPath",
        "fullPath",
        "isGroupFolder"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'name'
        QtMocHelpers::PropertyData<QString>(1, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'parentPath'
        QtMocHelpers::PropertyData<QString>(2, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'fullPath'
        QtMocHelpers::PropertyData<QString>(3, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'isGroupFolder'
        QtMocHelpers::PropertyData<bool>(4, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<TrayFolderInfo, qt_meta_tag_ZN3OCC14TrayFolderInfoE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject OCC::TrayFolderInfo::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3OCC14TrayFolderInfoE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3OCC14TrayFolderInfoE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3OCC14TrayFolderInfoE_t>.metaTypes,
    nullptr
} };

void OCC::TrayFolderInfo::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<TrayFolderInfo *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->_name; break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->_parentPath; break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->_fullPath; break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->isGroupFolder(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->_name, *reinterpret_cast<QString*>(_v)); break;
        case 1: QtMocHelpers::setProperty(_t->_parentPath, *reinterpret_cast<QString*>(_v)); break;
        case 2: QtMocHelpers::setProperty(_t->_fullPath, *reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN3OCC4UserE_t {};
} // unnamed namespace

template <> constexpr inline auto OCC::User::qt_create_metaobjectdata<qt_meta_tag_ZN3OCC4UserE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "OCC::User",
        "nameChanged",
        "",
        "hasLocalFolderChanged",
        "featuredAppChanged",
        "avatarChanged",
        "accountStateChanged",
        "statusChanged",
        "desktopNotificationsAllowedChanged",
        "headerColorChanged",
        "headerTextColorChanged",
        "accentColorChanged",
        "syncStatusChanged",
        "sendReplyMessage",
        "activityIndex",
        "conversationToken",
        "message",
        "replyTo",
        "groupFoldersChanged",
        "assistantStateChanged",
        "assistantQuestionChanged",
        "assistantResponseChanged",
        "assistantErrorChanged",
        "assistantMessagesChanged",
        "assistantRequestInProgressChanged",
        "slotItemCompleted",
        "folder",
        "OCC::SyncFileItemPtr",
        "item",
        "slotProgressInfo",
        "OCC::ProgressInfo",
        "progress",
        "slotAddError",
        "folderAlias",
        "OCC::ErrorCategory",
        "category",
        "slotAddErrorToGui",
        "OCC::SyncFileItem::Status",
        "status",
        "errorMessage",
        "subject",
        "slotAddNotification",
        "const OCC::Folder*",
        "OCC::Activity",
        "activity",
        "slotNotificationRequestFinished",
        "statusCode",
        "slotNotifyNetworkError",
        "QNetworkReply*",
        "reply",
        "slotEndNotificationRequest",
        "replyCode",
        "slotNotifyServerFinished",
        "slotSendNotificationRequest",
        "accountName",
        "link",
        "verb",
        "row",
        "slotBuildNotificationDisplay",
        "OCC::ActivityList",
        "list",
        "slotNotificationFetchFinished",
        "slotBuildIncomingCallDialogs",
        "slotRefreshNotifications",
        "slotRefreshActivitiesInitial",
        "slotRefreshActivities",
        "slotRefresh",
        "slotRefreshUserStatus",
        "slotRefreshImmediately",
        "setNotificationRefreshInterval",
        "std::chrono::milliseconds",
        "interval",
        "slotRebuildNavigationAppList",
        "slotSendReplyMessage",
        "forceSyncNow",
        "slotAccountCapabilitiesChangedRefreshGroupFolders",
        "slotFetchGroupFolders",
        "slotPushNotificationsReady",
        "slotDisconnectPushNotifications",
        "slotReceivedPushFilesChanges",
        "Account*",
        "account",
        "slotReceivedPushFileIdsChanges",
        "QList<qint64>",
        "fileIds",
        "slotReceivedPushNotification",
        "OCC::Account*",
        "slotReceivedPushActivity",
        "slotCheckExpiredActivities",
        "slotGroupFoldersFetched",
        "slotQuotaChanged",
        "int64_t",
        "usedBytes",
        "availableBytes",
        "slotAssistantPoll",
        "slotAssistantTaskTypesFetched",
        "QJsonDocument",
        "json",
        "slotAssistantTasksFetched",
        "slotAssistantTaskScheduled",
        "slotAssistantTaskDeleted",
        "slotAssistantRequestError",
        "context",
        "checkNotifiedNotifications",
        "showDesktopNotification",
        "title",
        "notificationId",
        "activityList",
        "showDesktopTalkNotification",
        "submitAssistantQuestion",
        "question",
        "clearAssistantResponse",
        "name",
        "server",
        "headerColor",
        "QColor",
        "headerTextColor",
        "accentColor",
        "serverHasUserStatus",
        "UserStatus::OnlineStatus",
        "statusIcon",
        "QUrl",
        "statusEmoji",
        "statusMessage",
        "desktopNotificationsAllowed",
        "hasLocalFolder",
        "isFeaturedAppEnabled",
        "featuredAppIcon",
        "featuredAppAccessibleName",
        "avatar",
        "syncStatusIcon",
        "syncStatusOk",
        "isConnected",
        "needsToSignTermsOfService",
        "unifiedSearchResultsListModel",
        "UnifiedSearchResultsListModel*",
        "groupFolders",
        "QVariantList",
        "canLogout",
        "isAssistantEnabled",
        "assistantQuestion",
        "assistantResponse",
        "assistantError",
        "assistantMessages",
        "assistantRequestInProgress"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'nameChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'hasLocalFolderChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'featuredAppChanged'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'avatarChanged'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'accountStateChanged'
        QtMocHelpers::SignalData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'statusChanged'
        QtMocHelpers::SignalData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'desktopNotificationsAllowedChanged'
        QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'headerColorChanged'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'headerTextColorChanged'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'accentColorChanged'
        QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'syncStatusChanged'
        QtMocHelpers::SignalData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sendReplyMessage'
        QtMocHelpers::SignalData<void(const int, const QString &, const QString &, const QString &)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 }, { QMetaType::QString, 15 }, { QMetaType::QString, 16 }, { QMetaType::QString, 17 },
        }}),
        // Signal 'groupFoldersChanged'
        QtMocHelpers::SignalData<void()>(18, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'assistantStateChanged'
        QtMocHelpers::SignalData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'assistantQuestionChanged'
        QtMocHelpers::SignalData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'assistantResponseChanged'
        QtMocHelpers::SignalData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'assistantErrorChanged'
        QtMocHelpers::SignalData<void()>(22, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'assistantMessagesChanged'
        QtMocHelpers::SignalData<void()>(23, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'assistantRequestInProgressChanged'
        QtMocHelpers::SignalData<void()>(24, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotItemCompleted'
        QtMocHelpers::SlotData<void(const QString &, const OCC::SyncFileItemPtr &)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 26 }, { 0x80000000 | 27, 28 },
        }}),
        // Slot 'slotProgressInfo'
        QtMocHelpers::SlotData<void(const QString &, const OCC::ProgressInfo &)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 26 }, { 0x80000000 | 30, 31 },
        }}),
        // Slot 'slotAddError'
        QtMocHelpers::SlotData<void(const QString &, const QString &, OCC::ErrorCategory)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 33 }, { QMetaType::QString, 16 }, { 0x80000000 | 34, 35 },
        }}),
        // Slot 'slotAddErrorToGui'
        QtMocHelpers::SlotData<void(const QString &, const OCC::SyncFileItem::Status, const QString &, const QString &, const OCC::ErrorCategory)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 33 }, { 0x80000000 | 37, 38 }, { QMetaType::QString, 39 }, { QMetaType::QString, 40 },
            { 0x80000000 | 34, 35 },
        }}),
        // Slot 'slotAddNotification'
        QtMocHelpers::SlotData<void(const OCC::Folder *, const OCC::Activity &)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 42, 26 }, { 0x80000000 | 43, 44 },
        }}),
        // Slot 'slotNotificationRequestFinished'
        QtMocHelpers::SlotData<void(int)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 46 },
        }}),
        // Slot 'slotNotifyNetworkError'
        QtMocHelpers::SlotData<void(QNetworkReply *)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'slotEndNotificationRequest'
        QtMocHelpers::SlotData<void(int)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 51 },
        }}),
        // Slot 'slotNotifyServerFinished'
        QtMocHelpers::SlotData<void(const QString &, int)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 49 }, { QMetaType::Int, 51 },
        }}),
        // Slot 'slotSendNotificationRequest'
        QtMocHelpers::SlotData<void(const QString &, const QString &, const QByteArray &, int)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 54 }, { QMetaType::QString, 55 }, { QMetaType::QByteArray, 56 }, { QMetaType::Int, 57 },
        }}),
        // Slot 'slotBuildNotificationDisplay'
        QtMocHelpers::SlotData<void(const OCC::ActivityList &)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 59, 60 },
        }}),
        // Slot 'slotNotificationFetchFinished'
        QtMocHelpers::SlotData<void()>(61, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotBuildIncomingCallDialogs'
        QtMocHelpers::SlotData<void(const OCC::ActivityList &)>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 59, 60 },
        }}),
        // Slot 'slotRefreshNotifications'
        QtMocHelpers::SlotData<void()>(63, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotRefreshActivitiesInitial'
        QtMocHelpers::SlotData<void()>(64, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotRefreshActivities'
        QtMocHelpers::SlotData<void()>(65, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotRefresh'
        QtMocHelpers::SlotData<void()>(66, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotRefreshUserStatus'
        QtMocHelpers::SlotData<void()>(67, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotRefreshImmediately'
        QtMocHelpers::SlotData<void()>(68, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setNotificationRefreshInterval'
        QtMocHelpers::SlotData<void(std::chrono::milliseconds)>(69, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 70, 71 },
        }}),
        // Slot 'slotRebuildNavigationAppList'
        QtMocHelpers::SlotData<void()>(72, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotSendReplyMessage'
        QtMocHelpers::SlotData<void(const int, const QString &, const QString &, const QString &)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 14 }, { QMetaType::QString, 15 }, { QMetaType::QString, 16 }, { QMetaType::QString, 17 },
        }}),
        // Slot 'forceSyncNow'
        QtMocHelpers::SlotData<void() const>(74, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotAccountCapabilitiesChangedRefreshGroupFolders'
        QtMocHelpers::SlotData<void()>(75, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotFetchGroupFolders'
        QtMocHelpers::SlotData<void()>(76, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotPushNotificationsReady'
        QtMocHelpers::SlotData<void()>(77, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'slotDisconnectPushNotifications'
        QtMocHelpers::SlotData<void()>(78, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'slotReceivedPushFilesChanges'
        QtMocHelpers::SlotData<void(Account *)>(79, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 80, 81 },
        }}),
        // Slot 'slotReceivedPushFileIdsChanges'
        QtMocHelpers::SlotData<void(Account *, const QList<qint64> &)>(82, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 80, 81 }, { 0x80000000 | 83, 84 },
        }}),
        // Slot 'slotReceivedPushNotification'
        QtMocHelpers::SlotData<void(OCC::Account *)>(85, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 86, 81 },
        }}),
        // Slot 'slotReceivedPushActivity'
        QtMocHelpers::SlotData<void(OCC::Account *)>(87, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 86, 81 },
        }}),
        // Slot 'slotCheckExpiredActivities'
        QtMocHelpers::SlotData<void()>(88, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'slotGroupFoldersFetched'
        QtMocHelpers::SlotData<void(QNetworkReply *)>(89, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'slotQuotaChanged'
        QtMocHelpers::SlotData<void(const int64_t &, const int64_t &)>(90, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 91, 92 }, { 0x80000000 | 91, 93 },
        }}),
        // Slot 'slotAssistantPoll'
        QtMocHelpers::SlotData<void()>(94, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'slotAssistantTaskTypesFetched'
        QtMocHelpers::SlotData<void(const QJsonDocument &, int)>(95, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 96, 97 }, { QMetaType::Int, 46 },
        }}),
        // Slot 'slotAssistantTasksFetched'
        QtMocHelpers::SlotData<void(const QJsonDocument &, int)>(98, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 96, 97 }, { QMetaType::Int, 46 },
        }}),
        // Slot 'slotAssistantTaskScheduled'
        QtMocHelpers::SlotData<void(const QJsonDocument &, int)>(99, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 96, 97 }, { QMetaType::Int, 46 },
        }}),
        // Slot 'slotAssistantTaskDeleted'
        QtMocHelpers::SlotData<void(int)>(100, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 46 },
        }}),
        // Slot 'slotAssistantRequestError'
        QtMocHelpers::SlotData<void(const QString &, int)>(101, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 102 }, { QMetaType::Int, 46 },
        }}),
        // Slot 'checkNotifiedNotifications'
        QtMocHelpers::SlotData<void()>(103, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'showDesktopNotification'
        QtMocHelpers::SlotData<void(const QString &, const QString &, const qint64)>(104, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 105 }, { QMetaType::QString, 16 }, { QMetaType::LongLong, 106 },
        }}),
        // Slot 'showDesktopNotification'
        QtMocHelpers::SlotData<void(const OCC::Activity &)>(104, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 43, 44 },
        }}),
        // Slot 'showDesktopNotification'
        QtMocHelpers::SlotData<void(const OCC::ActivityList &)>(104, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 59, 107 },
        }}),
        // Slot 'showDesktopTalkNotification'
        QtMocHelpers::SlotData<void(const OCC::Activity &)>(108, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 43, 44 },
        }}),
        // Method 'submitAssistantQuestion'
        QtMocHelpers::MethodData<void(const QString &)>(109, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 110 },
        }}),
        // Method 'clearAssistantResponse'
        QtMocHelpers::MethodData<void()>(111, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'name'
        QtMocHelpers::PropertyData<QString>(112, QMetaType::QString, QMC::DefaultPropertyFlags, 0),
        // property 'server'
        QtMocHelpers::PropertyData<QString>(113, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'headerColor'
        QtMocHelpers::PropertyData<QColor>(114, 0x80000000 | 115, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 7),
        // property 'headerTextColor'
        QtMocHelpers::PropertyData<QColor>(116, 0x80000000 | 115, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 8),
        // property 'accentColor'
        QtMocHelpers::PropertyData<QColor>(117, 0x80000000 | 115, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 9),
        // property 'serverHasUserStatus'
        QtMocHelpers::PropertyData<bool>(118, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'status'
        QtMocHelpers::PropertyData<UserStatus::OnlineStatus>(38, 0x80000000 | 119, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 5),
        // property 'statusIcon'
        QtMocHelpers::PropertyData<QUrl>(120, 0x80000000 | 121, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 5),
        // property 'statusEmoji'
        QtMocHelpers::PropertyData<QString>(122, QMetaType::QString, QMC::DefaultPropertyFlags, 5),
        // property 'statusMessage'
        QtMocHelpers::PropertyData<QString>(123, QMetaType::QString, QMC::DefaultPropertyFlags, 5),
        // property 'desktopNotificationsAllowed'
        QtMocHelpers::PropertyData<bool>(124, QMetaType::Bool, QMC::DefaultPropertyFlags, 6),
        // property 'hasLocalFolder'
        QtMocHelpers::PropertyData<bool>(125, QMetaType::Bool, QMC::DefaultPropertyFlags, 1),
        // property 'isFeaturedAppEnabled'
        QtMocHelpers::PropertyData<bool>(126, QMetaType::Bool, QMC::DefaultPropertyFlags, 2),
        // property 'featuredAppIcon'
        QtMocHelpers::PropertyData<QString>(127, QMetaType::QString, QMC::DefaultPropertyFlags, 2),
        // property 'featuredAppAccessibleName'
        QtMocHelpers::PropertyData<QString>(128, QMetaType::QString, QMC::DefaultPropertyFlags, 2),
        // property 'avatar'
        QtMocHelpers::PropertyData<QString>(129, QMetaType::QString, QMC::DefaultPropertyFlags, 3),
        // property 'syncStatusIcon'
        QtMocHelpers::PropertyData<QUrl>(130, 0x80000000 | 121, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 10),
        // property 'syncStatusOk'
        QtMocHelpers::PropertyData<bool>(131, QMetaType::Bool, QMC::DefaultPropertyFlags, 10),
        // property 'isConnected'
        QtMocHelpers::PropertyData<bool>(132, QMetaType::Bool, QMC::DefaultPropertyFlags, 4),
        // property 'needsToSignTermsOfService'
        QtMocHelpers::PropertyData<bool>(133, QMetaType::Bool, QMC::DefaultPropertyFlags, 4),
        // property 'unifiedSearchResultsListModel'
        QtMocHelpers::PropertyData<UnifiedSearchResultsListModel*>(134, 0x80000000 | 135, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'groupFolders'
        QtMocHelpers::PropertyData<QVariantList>(136, 0x80000000 | 137, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 12),
        // property 'canLogout'
        QtMocHelpers::PropertyData<bool>(138, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'isAssistantEnabled'
        QtMocHelpers::PropertyData<bool>(139, QMetaType::Bool, QMC::DefaultPropertyFlags, 13),
        // property 'assistantQuestion'
        QtMocHelpers::PropertyData<QString>(140, QMetaType::QString, QMC::DefaultPropertyFlags, 14),
        // property 'assistantResponse'
        QtMocHelpers::PropertyData<QString>(141, QMetaType::QString, QMC::DefaultPropertyFlags, 15),
        // property 'assistantError'
        QtMocHelpers::PropertyData<QString>(142, QMetaType::QString, QMC::DefaultPropertyFlags, 16),
        // property 'assistantMessages'
        QtMocHelpers::PropertyData<QVariantList>(143, 0x80000000 | 137, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 17),
        // property 'assistantRequestInProgress'
        QtMocHelpers::PropertyData<bool>(144, QMetaType::Bool, QMC::DefaultPropertyFlags, 18),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<User, qt_meta_tag_ZN3OCC4UserE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN3OCC4UserE[] = {
    QMetaObject::SuperData::link<OCC::UserStatus::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject OCC::User::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3OCC4UserE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3OCC4UserE_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN3OCC4UserE,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3OCC4UserE_t>.metaTypes,
    nullptr
} };

void OCC::User::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<User *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->nameChanged(); break;
        case 1: _t->hasLocalFolderChanged(); break;
        case 2: _t->featuredAppChanged(); break;
        case 3: _t->avatarChanged(); break;
        case 4: _t->accountStateChanged(); break;
        case 5: _t->statusChanged(); break;
        case 6: _t->desktopNotificationsAllowedChanged(); break;
        case 7: _t->headerColorChanged(); break;
        case 8: _t->headerTextColorChanged(); break;
        case 9: _t->accentColorChanged(); break;
        case 10: _t->syncStatusChanged(); break;
        case 11: _t->sendReplyMessage((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4]))); break;
        case 12: _t->groupFoldersChanged(); break;
        case 13: _t->assistantStateChanged(); break;
        case 14: _t->assistantQuestionChanged(); break;
        case 15: _t->assistantResponseChanged(); break;
        case 16: _t->assistantErrorChanged(); break;
        case 17: _t->assistantMessagesChanged(); break;
        case 18: _t->assistantRequestInProgressChanged(); break;
        case 19: _t->slotItemCompleted((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<OCC::SyncFileItemPtr>>(_a[2]))); break;
        case 20: _t->slotProgressInfo((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<OCC::ProgressInfo>>(_a[2]))); break;
        case 21: _t->slotAddError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<OCC::ErrorCategory>>(_a[3]))); break;
        case 22: _t->slotAddErrorToGui((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<OCC::SyncFileItem::Status>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<OCC::ErrorCategory>>(_a[5]))); break;
        case 23: _t->slotAddNotification((*reinterpret_cast<std::add_pointer_t<const OCC::Folder*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<OCC::Activity>>(_a[2]))); break;
        case 24: _t->slotNotificationRequestFinished((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 25: _t->slotNotifyNetworkError((*reinterpret_cast<std::add_pointer_t<QNetworkReply*>>(_a[1]))); break;
        case 26: _t->slotEndNotificationRequest((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 27: _t->slotNotifyServerFinished((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 28: _t->slotSendNotificationRequest((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 29: _t->slotBuildNotificationDisplay((*reinterpret_cast<std::add_pointer_t<OCC::ActivityList>>(_a[1]))); break;
        case 30: _t->slotNotificationFetchFinished(); break;
        case 31: _t->slotBuildIncomingCallDialogs((*reinterpret_cast<std::add_pointer_t<OCC::ActivityList>>(_a[1]))); break;
        case 32: _t->slotRefreshNotifications(); break;
        case 33: _t->slotRefreshActivitiesInitial(); break;
        case 34: _t->slotRefreshActivities(); break;
        case 35: _t->slotRefresh(); break;
        case 36: _t->slotRefreshUserStatus(); break;
        case 37: _t->slotRefreshImmediately(); break;
        case 38: _t->setNotificationRefreshInterval((*reinterpret_cast<std::add_pointer_t<std::chrono::milliseconds>>(_a[1]))); break;
        case 39: _t->slotRebuildNavigationAppList(); break;
        case 40: _t->slotSendReplyMessage((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4]))); break;
        case 41: _t->forceSyncNow(); break;
        case 42: _t->slotAccountCapabilitiesChangedRefreshGroupFolders(); break;
        case 43: _t->slotFetchGroupFolders(); break;
        case 44: _t->slotPushNotificationsReady(); break;
        case 45: _t->slotDisconnectPushNotifications(); break;
        case 46: _t->slotReceivedPushFilesChanges((*reinterpret_cast<std::add_pointer_t<Account*>>(_a[1]))); break;
        case 47: _t->slotReceivedPushFileIdsChanges((*reinterpret_cast<std::add_pointer_t<Account*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<qint64>>>(_a[2]))); break;
        case 48: _t->slotReceivedPushNotification((*reinterpret_cast<std::add_pointer_t<OCC::Account*>>(_a[1]))); break;
        case 49: _t->slotReceivedPushActivity((*reinterpret_cast<std::add_pointer_t<OCC::Account*>>(_a[1]))); break;
        case 50: _t->slotCheckExpiredActivities(); break;
        case 51: _t->slotGroupFoldersFetched((*reinterpret_cast<std::add_pointer_t<QNetworkReply*>>(_a[1]))); break;
        case 52: _t->slotQuotaChanged((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2]))); break;
        case 53: _t->slotAssistantPoll(); break;
        case 54: _t->slotAssistantTaskTypesFetched((*reinterpret_cast<std::add_pointer_t<QJsonDocument>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 55: _t->slotAssistantTasksFetched((*reinterpret_cast<std::add_pointer_t<QJsonDocument>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 56: _t->slotAssistantTaskScheduled((*reinterpret_cast<std::add_pointer_t<QJsonDocument>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 57: _t->slotAssistantTaskDeleted((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 58: _t->slotAssistantRequestError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 59: _t->checkNotifiedNotifications(); break;
        case 60: _t->showDesktopNotification((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<qint64>>(_a[3]))); break;
        case 61: _t->showDesktopNotification((*reinterpret_cast<std::add_pointer_t<OCC::Activity>>(_a[1]))); break;
        case 62: _t->showDesktopNotification((*reinterpret_cast<std::add_pointer_t<OCC::ActivityList>>(_a[1]))); break;
        case 63: _t->showDesktopTalkNotification((*reinterpret_cast<std::add_pointer_t<OCC::Activity>>(_a[1]))); break;
        case 64: _t->submitAssistantQuestion((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 65: _t->clearAssistantResponse(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 19:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< OCC::SyncFileItemPtr >(); break;
            }
            break;
        case 23:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< OCC::Activity >(); break;
            }
            break;
        case 25:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QNetworkReply* >(); break;
            }
            break;
        case 29:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< OCC::ActivityList >(); break;
            }
            break;
        case 31:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< OCC::ActivityList >(); break;
            }
            break;
        case 46:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Account* >(); break;
            }
            break;
        case 47:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Account* >(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<qint64> >(); break;
            }
            break;
        case 48:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< OCC::Account* >(); break;
            }
            break;
        case 49:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< OCC::Account* >(); break;
            }
            break;
        case 51:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QNetworkReply* >(); break;
            }
            break;
        case 61:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< OCC::Activity >(); break;
            }
            break;
        case 62:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< OCC::ActivityList >(); break;
            }
            break;
        case 63:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< OCC::Activity >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::nameChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::hasLocalFolderChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::featuredAppChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::avatarChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::accountStateChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::statusChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::desktopNotificationsAllowedChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::headerColorChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::headerTextColorChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::accentColorChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::syncStatusChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)(const int , const QString & , const QString & , const QString & )>(_a, &User::sendReplyMessage, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::groupFoldersChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::assistantStateChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::assistantQuestionChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::assistantResponseChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::assistantErrorChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::assistantMessagesChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (User::*)()>(_a, &User::assistantRequestInProgressChanged, 18))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->name(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->server(); break;
        case 2: *reinterpret_cast<QColor*>(_v) = _t->headerColor(); break;
        case 3: *reinterpret_cast<QColor*>(_v) = _t->headerTextColor(); break;
        case 4: *reinterpret_cast<QColor*>(_v) = _t->accentColor(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->serverHasUserStatus(); break;
        case 6: *reinterpret_cast<UserStatus::OnlineStatus*>(_v) = _t->status(); break;
        case 7: *reinterpret_cast<QUrl*>(_v) = _t->statusIcon(); break;
        case 8: *reinterpret_cast<QString*>(_v) = _t->statusEmoji(); break;
        case 9: *reinterpret_cast<QString*>(_v) = _t->statusMessage(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->isDesktopNotificationsAllowed(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->hasLocalFolder(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->isFeaturedAppEnabled(); break;
        case 13: *reinterpret_cast<QString*>(_v) = _t->featuredAppIcon(); break;
        case 14: *reinterpret_cast<QString*>(_v) = _t->featuredAppAccessibleName(); break;
        case 15: *reinterpret_cast<QString*>(_v) = _t->avatarUrl(); break;
        case 16: *reinterpret_cast<QUrl*>(_v) = _t->syncStatusIcon(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->syncStatusOk(); break;
        case 18: *reinterpret_cast<bool*>(_v) = _t->isConnected(); break;
        case 19: *reinterpret_cast<bool*>(_v) = _t->needsToSignTermsOfService(); break;
        case 20: *reinterpret_cast<UnifiedSearchResultsListModel**>(_v) = _t->getUnifiedSearchResultsListModel(); break;
        case 21: *reinterpret_cast<QVariantList*>(_v) = _t->groupFolders(); break;
        case 22: *reinterpret_cast<bool*>(_v) = _t->canLogout(); break;
        case 23: *reinterpret_cast<bool*>(_v) = _t->isNcAssistantEnabled(); break;
        case 24: *reinterpret_cast<QString*>(_v) = _t->assistantQuestion(); break;
        case 25: *reinterpret_cast<QString*>(_v) = _t->assistantResponse(); break;
        case 26: *reinterpret_cast<QString*>(_v) = _t->assistantError(); break;
        case 27: *reinterpret_cast<QVariantList*>(_v) = _t->assistantMessages(); break;
        case 28: *reinterpret_cast<bool*>(_v) = _t->assistantRequestInProgress(); break;
        default: break;
        }
    }
}

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

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

int OCC::User::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 < 66)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 66;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 66)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 66;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 29;
    }
    return _id;
}

// SIGNAL 0
void OCC::User::nameChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void OCC::User::hasLocalFolderChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void OCC::User::featuredAppChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void OCC::User::avatarChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void OCC::User::accountStateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void OCC::User::statusChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void OCC::User::desktopNotificationsAllowedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void OCC::User::headerColorChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void OCC::User::headerTextColorChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void OCC::User::accentColorChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void OCC::User::syncStatusChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void OCC::User::sendReplyMessage(const int _t1, const QString & _t2, const QString & _t3, const QString & _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 12
void OCC::User::groupFoldersChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}

// SIGNAL 13
void OCC::User::assistantStateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void OCC::User::assistantQuestionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void OCC::User::assistantResponseChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void OCC::User::assistantErrorChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void OCC::User::assistantMessagesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void OCC::User::assistantRequestInProgressChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 18, nullptr);
}
namespace {
struct qt_meta_tag_ZN3OCC9UserModelE_t {};
} // unnamed namespace

template <> constexpr inline auto OCC::UserModel::qt_create_metaobjectdata<qt_meta_tag_ZN3OCC9UserModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "OCC::UserModel",
        "addAccount",
        "",
        "currentUserChanged",
        "syncErrorUsersChanged",
        "fetchCurrentActivityModel",
        "openCurrentAccountLocalFolder",
        "openCurrentAccountServer",
        "openCurrentAccountFolderFromTrayInfo",
        "fullRemotePath",
        "openCurrentAccountFeaturedApp",
        "refreshSyncErrorUsers",
        "setCurrentUserId",
        "id",
        "login",
        "logout",
        "removeAccount",
        "numUsers",
        "currentUserServer",
        "isUserConnected",
        "userStatusConnector",
        "std::shared_ptr<OCC::UserStatusConnector>",
        "currentUser",
        "User*",
        "currentUserId",
        "hasSyncErrors",
        "syncErrorUserCount",
        "firstSyncErrorUserId",
        "firstSyncErrorUser"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'addAccount'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'currentUserChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'syncErrorUsersChanged'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'fetchCurrentActivityModel'
        QtMocHelpers::SlotData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openCurrentAccountLocalFolder'
        QtMocHelpers::SlotData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openCurrentAccountServer'
        QtMocHelpers::SlotData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'openCurrentAccountFolderFromTrayInfo'
        QtMocHelpers::SlotData<void(const QString &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 9 },
        }}),
        // Slot 'openCurrentAccountFeaturedApp'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'refreshSyncErrorUsers'
        QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setCurrentUserId'
        QtMocHelpers::SlotData<void(const int)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Slot 'login'
        QtMocHelpers::SlotData<void(const int)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Slot 'logout'
        QtMocHelpers::SlotData<void(const int)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Slot 'removeAccount'
        QtMocHelpers::SlotData<void(const int)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 13 },
        }}),
        // Method 'numUsers'
        QtMocHelpers::MethodData<int()>(17, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'currentUserServer'
        QtMocHelpers::MethodData<QString()>(18, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'isUserConnected'
        QtMocHelpers::MethodData<bool(const int)>(19, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Int, 13 },
        }}),
        // Method 'userStatusConnector'
        QtMocHelpers::MethodData<std::shared_ptr<OCC::UserStatusConnector>(int)>(20, 2, QMC::AccessPublic, 0x80000000 | 21, {{
            { QMetaType::Int, 13 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'currentUser'
        QtMocHelpers::PropertyData<User*>(22, 0x80000000 | 23, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
        // property 'currentUserId'
        QtMocHelpers::PropertyData<int>(24, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'hasSyncErrors'
        QtMocHelpers::PropertyData<bool>(25, QMetaType::Bool, QMC::DefaultPropertyFlags, 2),
        // property 'syncErrorUserCount'
        QtMocHelpers::PropertyData<int>(26, QMetaType::Int, QMC::DefaultPropertyFlags, 2),
        // property 'firstSyncErrorUserId'
        QtMocHelpers::PropertyData<int>(27, QMetaType::Int, QMC::DefaultPropertyFlags, 2),
        // property 'firstSyncErrorUser'
        QtMocHelpers::PropertyData<User*>(28, 0x80000000 | 23, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 2),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<UserModel, qt_meta_tag_ZN3OCC9UserModelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject OCC::UserModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractListModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3OCC9UserModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3OCC9UserModelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3OCC9UserModelE_t>.metaTypes,
    nullptr
} };

void OCC::UserModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<UserModel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->addAccount(); break;
        case 1: _t->currentUserChanged(); break;
        case 2: _t->syncErrorUsersChanged(); break;
        case 3: _t->fetchCurrentActivityModel(); break;
        case 4: _t->openCurrentAccountLocalFolder(); break;
        case 5: _t->openCurrentAccountServer(); break;
        case 6: _t->openCurrentAccountFolderFromTrayInfo((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 7: _t->openCurrentAccountFeaturedApp(); break;
        case 8: _t->refreshSyncErrorUsers(); break;
        case 9: _t->setCurrentUserId((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 10: _t->login((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 11: _t->logout((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 12: _t->removeAccount((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 13: { int _r = _t->numUsers();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 14: { QString _r = _t->currentUserServer();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 15: { bool _r = _t->isUserConnected((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 16: { std::shared_ptr<OCC::UserStatusConnector> _r = _t->userStatusConnector((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<std::shared_ptr<OCC::UserStatusConnector>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (UserModel::*)()>(_a, &UserModel::addAccount, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (UserModel::*)()>(_a, &UserModel::currentUserChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (UserModel::*)()>(_a, &UserModel::syncErrorUsersChanged, 2))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 5:
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< User* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<User**>(_v) = _t->currentUser(); break;
        case 1: *reinterpret_cast<int*>(_v) = _t->currentUserId(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->hasSyncErrors(); break;
        case 3: *reinterpret_cast<int*>(_v) = _t->syncErrorUserCount(); break;
        case 4: *reinterpret_cast<int*>(_v) = _t->firstSyncErrorUserId(); break;
        case 5: *reinterpret_cast<User**>(_v) = _t->firstSyncErrorUser(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 1: _t->setCurrentUserId(*reinterpret_cast<int*>(_v)); break;
        default: break;
        }
    }
}

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

void *OCC::UserModel::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3OCC9UserModelE_t>.strings))
        return static_cast<void*>(this);
    return QAbstractListModel::qt_metacast(_clname);
}

int OCC::UserModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractListModel::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 17)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 17;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 17)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 17;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 6;
    }
    return _id;
}

// SIGNAL 0
void OCC::UserModel::addAccount()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void OCC::UserModel::currentUserChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void OCC::UserModel::syncErrorUsersChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}
namespace {
struct qt_meta_tag_ZN3OCC13ImageProviderE_t {};
} // unnamed namespace

template <> constexpr inline auto OCC::ImageProvider::qt_create_metaobjectdata<qt_meta_tag_ZN3OCC13ImageProviderE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "OCC::ImageProvider"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ImageProvider, qt_meta_tag_ZN3OCC13ImageProviderE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject OCC::ImageProvider::staticMetaObject = { {
    QMetaObject::SuperData::link<QQuickAsyncImageProvider::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3OCC13ImageProviderE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3OCC13ImageProviderE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3OCC13ImageProviderE_t>.metaTypes,
    nullptr
} };

void OCC::ImageProvider::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ImageProvider *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

void *OCC::ImageProvider::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3OCC13ImageProviderE_t>.strings))
        return static_cast<void*>(this);
    return QQuickAsyncImageProvider::qt_metacast(_clname);
}

int OCC::ImageProvider::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QQuickAsyncImageProvider::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3OCC13UserAppsModelE_t {};
} // unnamed namespace

template <> constexpr inline auto OCC::UserAppsModel::qt_create_metaobjectdata<qt_meta_tag_ZN3OCC13UserAppsModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "OCC::UserAppsModel",
        "openAppUrl",
        "",
        "QUrl",
        "url"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'openAppUrl'
        QtMocHelpers::SlotData<void(const QUrl &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<UserAppsModel, qt_meta_tag_ZN3OCC13UserAppsModelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject OCC::UserAppsModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractListModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3OCC13UserAppsModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3OCC13UserAppsModelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3OCC13UserAppsModelE_t>.metaTypes,
    nullptr
} };

void OCC::UserAppsModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<UserAppsModel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->openAppUrl((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        default: ;
        }
    }
}

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

void *OCC::UserAppsModel::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3OCC13UserAppsModelE_t>.strings))
        return static_cast<void*>(this);
    return QAbstractListModel::qt_metacast(_clname);
}

int OCC::UserAppsModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractListModel::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
QT_WARNING_POP
