/****************************************************************************
** Meta object code from reading C++ file 'account.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/libsync/account.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 'account.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_ZN3OCC7AccountE_t {};
} // unnamed namespace

template <> constexpr inline auto OCC::Account::qt_create_metaobjectdata<qt_meta_tag_ZN3OCC7AccountE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "OCC::Account",
        "propagatorNetworkActivity",
        "",
        "invalidCredentials",
        "credentialsFetched",
        "OCC::AbstractCredentials*",
        "credentials",
        "credentialsAsked",
        "proxyAuthenticationRequired",
        "QNetworkProxy",
        "QAuthenticator*",
        "wantsAccountSaved",
        "OCC::AccountPtr",
        "acc",
        "wantsFoldersSynced",
        "serverVersionChanged",
        "account",
        "newVersion",
        "oldVersion",
        "accountChangedAvatar",
        "accountChangedDisplayName",
        "prettyNameChanged",
        "askUserForMnemonicChanged",
        "enforceUseHardwareTokenEncryptionChanged",
        "encryptionHardwareTokenDriverPathChanged",
        "appPasswordRetrieved",
        "pushNotificationsReady",
        "pushNotificationsDisabled",
        "userStatusChanged",
        "serverUserStatusChanged",
        "capabilitiesChanged",
        "lockFileSuccess",
        "lockFileError",
        "networkProxySettingChanged",
        "proxyTypeChanged",
        "proxyHostNameChanged",
        "proxyPortChanged",
        "proxyNeedsAuthChanged",
        "proxyUserChanged",
        "proxyPasswordChanged",
        "uploadLimitSettingChanged",
        "downloadLimitSettingChanged",
        "uploadLimitChanged",
        "downloadLimitChanged",
        "termsOfServiceNeedToBeChecked",
        "encryptionCertificateFingerprintChanged",
        "userCertificateNeedsMigrationChanged",
        "rootFolderQuotaChanged",
        "int64_t",
        "usedBytes",
        "availableBytes",
        "clearQNAMCache",
        "slotHandleSslErrors",
        "QNetworkReply*",
        "QList<QSslError>",
        "setAskUserForMnemonic",
        "ask",
        "listRemoteFolder",
        "QPromise<OCC::PlaceholderCreateInfo>*",
        "promise",
        "remoteSyncRootPath",
        "subPath",
        "OCC::SyncJournalDb*",
        "journalForFolder",
        "slotCredentialsFetched",
        "slotCredentialsAsked",
        "slotDirectEditingRecieved",
        "QJsonDocument",
        "json",
        "removeLockStatusChangeInprogress",
        "serverRelativePath",
        "OCC::SyncFileItemEnums::LockStatus",
        "lockStatus",
        "id",
        "davUser",
        "davDisplayName",
        "prettyName",
        "url",
        "QUrl",
        "e2eEncryptionKeysGenerationAllowed",
        "askUserForMnemonic",
        "proxyType",
        "QNetworkProxy::ProxyType",
        "proxyHostName",
        "proxyPort",
        "proxyNeedsAuth",
        "proxyUser",
        "proxyPassword",
        "uploadLimitSetting",
        "AccountNetworkTransferLimitSetting",
        "downloadLimitSetting",
        "uploadLimit",
        "downloadLimit",
        "enforceUseHardwareTokenEncryption",
        "encryptionHardwareTokenDriverPath",
        "encryptionCertificateFingerprint",
        "LegacyGlobalLimit",
        "AutoLimit",
        "NoLimit",
        "ManualLimit"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'propagatorNetworkActivity'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'invalidCredentials'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'credentialsFetched'
        QtMocHelpers::SignalData<void(OCC::AbstractCredentials *)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Signal 'credentialsAsked'
        QtMocHelpers::SignalData<void(OCC::AbstractCredentials *)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Signal 'proxyAuthenticationRequired'
        QtMocHelpers::SignalData<void(const QNetworkProxy &, QAuthenticator *)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 2 }, { 0x80000000 | 10, 2 },
        }}),
        // Signal 'wantsAccountSaved'
        QtMocHelpers::SignalData<void(const OCC::AccountPtr &)>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 13 },
        }}),
        // Signal 'wantsFoldersSynced'
        QtMocHelpers::SignalData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'serverVersionChanged'
        QtMocHelpers::SignalData<void(const OCC::AccountPtr &, const QString &, const QString &)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 16 }, { QMetaType::QString, 17 }, { QMetaType::QString, 18 },
        }}),
        // Signal 'accountChangedAvatar'
        QtMocHelpers::SignalData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'accountChangedDisplayName'
        QtMocHelpers::SignalData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'prettyNameChanged'
        QtMocHelpers::SignalData<void()>(21, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'askUserForMnemonicChanged'
        QtMocHelpers::SignalData<void()>(22, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'enforceUseHardwareTokenEncryptionChanged'
        QtMocHelpers::SignalData<void()>(23, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'encryptionHardwareTokenDriverPathChanged'
        QtMocHelpers::SignalData<void()>(24, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'appPasswordRetrieved'
        QtMocHelpers::SignalData<void(QString)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Signal 'pushNotificationsReady'
        QtMocHelpers::SignalData<void(const OCC::AccountPtr &)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 16 },
        }}),
        // Signal 'pushNotificationsDisabled'
        QtMocHelpers::SignalData<void(const OCC::AccountPtr &)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 12, 16 },
        }}),
        // Signal 'userStatusChanged'
        QtMocHelpers::SignalData<void()>(28, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'serverUserStatusChanged'
        QtMocHelpers::SignalData<void()>(29, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'capabilitiesChanged'
        QtMocHelpers::SignalData<void()>(30, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lockFileSuccess'
        QtMocHelpers::SignalData<void()>(31, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lockFileError'
        QtMocHelpers::SignalData<void(const QString &)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 2 },
        }}),
        // Signal 'networkProxySettingChanged'
        QtMocHelpers::SignalData<void()>(33, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'proxyTypeChanged'
        QtMocHelpers::SignalData<void()>(34, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'proxyHostNameChanged'
        QtMocHelpers::SignalData<void()>(35, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'proxyPortChanged'
        QtMocHelpers::SignalData<void()>(36, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'proxyNeedsAuthChanged'
        QtMocHelpers::SignalData<void()>(37, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'proxyUserChanged'
        QtMocHelpers::SignalData<void()>(38, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'proxyPasswordChanged'
        QtMocHelpers::SignalData<void()>(39, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'uploadLimitSettingChanged'
        QtMocHelpers::SignalData<void()>(40, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'downloadLimitSettingChanged'
        QtMocHelpers::SignalData<void()>(41, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'uploadLimitChanged'
        QtMocHelpers::SignalData<void()>(42, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'downloadLimitChanged'
        QtMocHelpers::SignalData<void()>(43, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'termsOfServiceNeedToBeChecked'
        QtMocHelpers::SignalData<void()>(44, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'encryptionCertificateFingerprintChanged'
        QtMocHelpers::SignalData<void()>(45, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'userCertificateNeedsMigrationChanged'
        QtMocHelpers::SignalData<void()>(46, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'rootFolderQuotaChanged'
        QtMocHelpers::SignalData<void(const int64_t &, const int64_t &)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 49 }, { 0x80000000 | 48, 50 },
        }}),
        // Slot 'clearQNAMCache'
        QtMocHelpers::SlotData<void()>(51, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'slotHandleSslErrors'
        QtMocHelpers::SlotData<void(QNetworkReply *, QList<QSslError>)>(52, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 53, 2 }, { 0x80000000 | 54, 2 },
        }}),
        // Slot 'setAskUserForMnemonic'
        QtMocHelpers::SlotData<void(const bool)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 56 },
        }}),
        // Slot 'listRemoteFolder'
        QtMocHelpers::SlotData<void(QPromise<OCC::PlaceholderCreateInfo> *, const QString &, const QString &, OCC::SyncJournalDb *)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 58, 59 }, { QMetaType::QString, 60 }, { QMetaType::QString, 61 }, { 0x80000000 | 62, 63 },
        }}),
        // Slot 'slotCredentialsFetched'
        QtMocHelpers::SlotData<void()>(64, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'slotCredentialsAsked'
        QtMocHelpers::SlotData<void()>(65, 2, QMC::AccessProtected, QMetaType::Void),
        // Slot 'slotDirectEditingRecieved'
        QtMocHelpers::SlotData<void(const QJsonDocument &)>(66, 2, QMC::AccessProtected, QMetaType::Void, {{
            { 0x80000000 | 67, 68 },
        }}),
        // Slot 'removeLockStatusChangeInprogress'
        QtMocHelpers::SlotData<void(const QString &, const OCC::SyncFileItemEnums::LockStatus)>(69, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 70 }, { 0x80000000 | 71, 72 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'id'
        QtMocHelpers::PropertyData<QString>(73, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'davUser'
        QtMocHelpers::PropertyData<QString>(74, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'davDisplayName'
        QtMocHelpers::PropertyData<QString>(75, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'prettyName'
        QtMocHelpers::PropertyData<QString>(76, QMetaType::QString, QMC::DefaultPropertyFlags, 10),
        // property 'url'
        QtMocHelpers::PropertyData<QUrl>(77, 0x80000000 | 78, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag),
        // property 'e2eEncryptionKeysGenerationAllowed'
        QtMocHelpers::PropertyData<bool>(79, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'askUserForMnemonic'
        QtMocHelpers::PropertyData<bool>(80, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 11),
        // property 'proxyType'
        QtMocHelpers::PropertyData<QNetworkProxy::ProxyType>(81, 0x80000000 | 82, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 23),
        // property 'proxyHostName'
        QtMocHelpers::PropertyData<QString>(83, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 24),
        // property 'proxyPort'
        QtMocHelpers::PropertyData<int>(84, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 25),
        // property 'proxyNeedsAuth'
        QtMocHelpers::PropertyData<bool>(85, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 26),
        // property 'proxyUser'
        QtMocHelpers::PropertyData<QString>(86, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 27),
        // property 'proxyPassword'
        QtMocHelpers::PropertyData<QString>(87, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 28),
        // property 'uploadLimitSetting'
        QtMocHelpers::PropertyData<enum AccountNetworkTransferLimitSetting>(88, 0x80000000 | 89, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 29),
        // property 'downloadLimitSetting'
        QtMocHelpers::PropertyData<enum AccountNetworkTransferLimitSetting>(90, 0x80000000 | 89, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 30),
        // property 'uploadLimit'
        QtMocHelpers::PropertyData<uint>(91, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 31),
        // property 'downloadLimit'
        QtMocHelpers::PropertyData<uint>(92, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 32),
        // property 'enforceUseHardwareTokenEncryption'
        QtMocHelpers::PropertyData<bool>(93, QMetaType::Bool, QMC::DefaultPropertyFlags, 12),
        // property 'encryptionHardwareTokenDriverPath'
        QtMocHelpers::PropertyData<QString>(94, QMetaType::QString, QMC::DefaultPropertyFlags, 13),
        // property 'encryptionCertificateFingerprint'
        QtMocHelpers::PropertyData<QByteArray>(95, QMetaType::QByteArray, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 34),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'AccountNetworkTransferLimitSetting'
        QtMocHelpers::EnumData<enum AccountNetworkTransferLimitSetting>(89, 89, QMC::EnumIsScoped).add({
            {   96, AccountNetworkTransferLimitSetting::LegacyGlobalLimit },
            {   97, AccountNetworkTransferLimitSetting::AutoLimit },
            {   98, AccountNetworkTransferLimitSetting::NoLimit },
            {   99, AccountNetworkTransferLimitSetting::ManualLimit },
        }),
    };
    return QtMocHelpers::metaObjectData<Account, qt_meta_tag_ZN3OCC7AccountE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN3OCC7AccountE[] = {
    QMetaObject::SuperData::link<QNetworkProxy::staticMetaObject>(),
    nullptr
};

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

void OCC::Account::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Account *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->propagatorNetworkActivity(); break;
        case 1: _t->invalidCredentials(); break;
        case 2: _t->credentialsFetched((*reinterpret_cast<std::add_pointer_t<OCC::AbstractCredentials*>>(_a[1]))); break;
        case 3: _t->credentialsAsked((*reinterpret_cast<std::add_pointer_t<OCC::AbstractCredentials*>>(_a[1]))); break;
        case 4: _t->proxyAuthenticationRequired((*reinterpret_cast<std::add_pointer_t<QNetworkProxy>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QAuthenticator*>>(_a[2]))); break;
        case 5: _t->wantsAccountSaved((*reinterpret_cast<std::add_pointer_t<OCC::AccountPtr>>(_a[1]))); break;
        case 6: _t->wantsFoldersSynced(); break;
        case 7: _t->serverVersionChanged((*reinterpret_cast<std::add_pointer_t<OCC::AccountPtr>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 8: _t->accountChangedAvatar(); break;
        case 9: _t->accountChangedDisplayName(); break;
        case 10: _t->prettyNameChanged(); break;
        case 11: _t->askUserForMnemonicChanged(); break;
        case 12: _t->enforceUseHardwareTokenEncryptionChanged(); break;
        case 13: _t->encryptionHardwareTokenDriverPathChanged(); break;
        case 14: _t->appPasswordRetrieved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 15: _t->pushNotificationsReady((*reinterpret_cast<std::add_pointer_t<OCC::AccountPtr>>(_a[1]))); break;
        case 16: _t->pushNotificationsDisabled((*reinterpret_cast<std::add_pointer_t<OCC::AccountPtr>>(_a[1]))); break;
        case 17: _t->userStatusChanged(); break;
        case 18: _t->serverUserStatusChanged(); break;
        case 19: _t->capabilitiesChanged(); break;
        case 20: _t->lockFileSuccess(); break;
        case 21: _t->lockFileError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 22: _t->networkProxySettingChanged(); break;
        case 23: _t->proxyTypeChanged(); break;
        case 24: _t->proxyHostNameChanged(); break;
        case 25: _t->proxyPortChanged(); break;
        case 26: _t->proxyNeedsAuthChanged(); break;
        case 27: _t->proxyUserChanged(); break;
        case 28: _t->proxyPasswordChanged(); break;
        case 29: _t->uploadLimitSettingChanged(); break;
        case 30: _t->downloadLimitSettingChanged(); break;
        case 31: _t->uploadLimitChanged(); break;
        case 32: _t->downloadLimitChanged(); break;
        case 33: _t->termsOfServiceNeedToBeChecked(); break;
        case 34: _t->encryptionCertificateFingerprintChanged(); break;
        case 35: _t->userCertificateNeedsMigrationChanged(); break;
        case 36: _t->rootFolderQuotaChanged((*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int64_t>>(_a[2]))); break;
        case 37: _t->clearQNAMCache(); break;
        case 38: _t->slotHandleSslErrors((*reinterpret_cast<std::add_pointer_t<QNetworkReply*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<QSslError>>>(_a[2]))); break;
        case 39: _t->setAskUserForMnemonic((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 40: _t->listRemoteFolder((*reinterpret_cast<std::add_pointer_t<QPromise<OCC::PlaceholderCreateInfo>*>>(_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<OCC::SyncJournalDb*>>(_a[4]))); break;
        case 41: _t->slotCredentialsFetched(); break;
        case 42: _t->slotCredentialsAsked(); break;
        case 43: _t->slotDirectEditingRecieved((*reinterpret_cast<std::add_pointer_t<QJsonDocument>>(_a[1]))); break;
        case 44: _t->removeLockStatusChangeInprogress((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<OCC::SyncFileItemEnums::LockStatus>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 4:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QNetworkProxy >(); break;
            }
            break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< OCC::AccountPtr >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< OCC::AccountPtr >(); break;
            }
            break;
        case 15:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< OCC::AccountPtr >(); break;
            }
            break;
        case 16:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< OCC::AccountPtr >(); break;
            }
            break;
        case 38:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QSslError> >(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QNetworkReply* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::propagatorNetworkActivity, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::invalidCredentials, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)(OCC::AbstractCredentials * )>(_a, &Account::credentialsFetched, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)(OCC::AbstractCredentials * )>(_a, &Account::credentialsAsked, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)(const QNetworkProxy & , QAuthenticator * )>(_a, &Account::proxyAuthenticationRequired, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)(const OCC::AccountPtr & )>(_a, &Account::wantsAccountSaved, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::wantsFoldersSynced, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)(const OCC::AccountPtr & , const QString & , const QString & )>(_a, &Account::serverVersionChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::accountChangedAvatar, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::accountChangedDisplayName, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::prettyNameChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::askUserForMnemonicChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::enforceUseHardwareTokenEncryptionChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::encryptionHardwareTokenDriverPathChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)(QString )>(_a, &Account::appPasswordRetrieved, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)(const OCC::AccountPtr & )>(_a, &Account::pushNotificationsReady, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)(const OCC::AccountPtr & )>(_a, &Account::pushNotificationsDisabled, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::userStatusChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::serverUserStatusChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::capabilitiesChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::lockFileSuccess, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)(const QString & )>(_a, &Account::lockFileError, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::networkProxySettingChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::proxyTypeChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::proxyHostNameChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::proxyPortChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::proxyNeedsAuthChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::proxyUserChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::proxyPasswordChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::uploadLimitSettingChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::downloadLimitSettingChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::uploadLimitChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::downloadLimitChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::termsOfServiceNeedToBeChecked, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::encryptionCertificateFingerprintChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)()>(_a, &Account::userCertificateNeedsMigrationChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (Account::*)(const int64_t & , const int64_t & )>(_a, &Account::rootFolderQuotaChanged, 36))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->_id; break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->_davUser; break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->_davDisplayName; break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->prettyName(); break;
        case 4: *reinterpret_cast<QUrl*>(_v) = _t->_url; break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->_e2eEncryptionKeysGenerationAllowed; break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->askUserForMnemonic(); break;
        case 7: *reinterpret_cast<QNetworkProxy::ProxyType*>(_v) = _t->proxyType(); break;
        case 8: *reinterpret_cast<QString*>(_v) = _t->proxyHostName(); break;
        case 9: *reinterpret_cast<int*>(_v) = _t->proxyPort(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->proxyNeedsAuth(); break;
        case 11: *reinterpret_cast<QString*>(_v) = _t->proxyUser(); break;
        case 12: *reinterpret_cast<QString*>(_v) = _t->proxyPassword(); break;
        case 13: *reinterpret_cast<enum AccountNetworkTransferLimitSetting*>(_v) = _t->uploadLimitSetting(); break;
        case 14: *reinterpret_cast<enum AccountNetworkTransferLimitSetting*>(_v) = _t->downloadLimitSetting(); break;
        case 15: *reinterpret_cast<uint*>(_v) = _t->uploadLimit(); break;
        case 16: *reinterpret_cast<uint*>(_v) = _t->downloadLimit(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->enforceUseHardwareTokenEncryption(); break;
        case 18: *reinterpret_cast<QString*>(_v) = _t->encryptionHardwareTokenDriverPath(); break;
        case 19: *reinterpret_cast<QByteArray*>(_v) = _t->encryptionCertificateFingerprint(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->_id, *reinterpret_cast<QString*>(_v)); break;
        case 1: QtMocHelpers::setProperty(_t->_davUser, *reinterpret_cast<QString*>(_v)); break;
        case 2: QtMocHelpers::setProperty(_t->_davDisplayName, *reinterpret_cast<QString*>(_v)); break;
        case 4: QtMocHelpers::setProperty(_t->_url, *reinterpret_cast<QUrl*>(_v)); break;
        case 5: QtMocHelpers::setProperty(_t->_e2eEncryptionKeysGenerationAllowed, *reinterpret_cast<bool*>(_v)); break;
        case 6: _t->setAskUserForMnemonic(*reinterpret_cast<bool*>(_v)); break;
        case 7: _t->setProxyType(*reinterpret_cast<QNetworkProxy::ProxyType*>(_v)); break;
        case 8: _t->setProxyHostName(*reinterpret_cast<QString*>(_v)); break;
        case 9: _t->setProxyPort(*reinterpret_cast<int*>(_v)); break;
        case 10: _t->setProxyNeedsAuth(*reinterpret_cast<bool*>(_v)); break;
        case 11: _t->setProxyUser(*reinterpret_cast<QString*>(_v)); break;
        case 12: _t->setProxyPassword(*reinterpret_cast<QString*>(_v)); break;
        case 13: _t->setUploadLimitSetting(*reinterpret_cast<enum AccountNetworkTransferLimitSetting*>(_v)); break;
        case 14: _t->setDownloadLimitSetting(*reinterpret_cast<enum AccountNetworkTransferLimitSetting*>(_v)); break;
        case 15: _t->setUploadLimit(*reinterpret_cast<uint*>(_v)); break;
        case 16: _t->setDownloadLimit(*reinterpret_cast<uint*>(_v)); break;
        case 19: _t->setEncryptionCertificateFingerprint(*reinterpret_cast<QByteArray*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

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

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

// SIGNAL 2
void OCC::Account::credentialsFetched(OCC::AbstractCredentials * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void OCC::Account::credentialsAsked(OCC::AbstractCredentials * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void OCC::Account::proxyAuthenticationRequired(const QNetworkProxy & _t1, QAuthenticator * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1, _t2);
}

// SIGNAL 5
void OCC::Account::wantsAccountSaved(const OCC::AccountPtr & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

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

// SIGNAL 7
void OCC::Account::serverVersionChanged(const OCC::AccountPtr & _t1, const QString & _t2, const QString & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1, _t2, _t3);
}

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

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

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

// SIGNAL 11
void OCC::Account::askUserForMnemonicChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

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

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

// SIGNAL 14
void OCC::Account::appPasswordRetrieved(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void OCC::Account::pushNotificationsReady(const OCC::AccountPtr & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void OCC::Account::pushNotificationsDisabled(const OCC::AccountPtr & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

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

// SIGNAL 18
void OCC::Account::serverUserStatusChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 18, nullptr);
}

// SIGNAL 19
void OCC::Account::capabilitiesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 19, nullptr);
}

// SIGNAL 20
void OCC::Account::lockFileSuccess()
{
    QMetaObject::activate(this, &staticMetaObject, 20, nullptr);
}

// SIGNAL 21
void OCC::Account::lockFileError(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void OCC::Account::networkProxySettingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}

// SIGNAL 23
void OCC::Account::proxyTypeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 23, nullptr);
}

// SIGNAL 24
void OCC::Account::proxyHostNameChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 24, nullptr);
}

// SIGNAL 25
void OCC::Account::proxyPortChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 25, nullptr);
}

// SIGNAL 26
void OCC::Account::proxyNeedsAuthChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 26, nullptr);
}

// SIGNAL 27
void OCC::Account::proxyUserChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 27, nullptr);
}

// SIGNAL 28
void OCC::Account::proxyPasswordChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 28, nullptr);
}

// SIGNAL 29
void OCC::Account::uploadLimitSettingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 29, nullptr);
}

// SIGNAL 30
void OCC::Account::downloadLimitSettingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 30, nullptr);
}

// SIGNAL 31
void OCC::Account::uploadLimitChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 31, nullptr);
}

// SIGNAL 32
void OCC::Account::downloadLimitChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 32, nullptr);
}

// SIGNAL 33
void OCC::Account::termsOfServiceNeedToBeChecked()
{
    QMetaObject::activate(this, &staticMetaObject, 33, nullptr);
}

// SIGNAL 34
void OCC::Account::encryptionCertificateFingerprintChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 34, nullptr);
}

// SIGNAL 35
void OCC::Account::userCertificateNeedsMigrationChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 35, nullptr);
}

// SIGNAL 36
void OCC::Account::rootFolderQuotaChanged(const int64_t & _t1, const int64_t & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 36, nullptr, _t1, _t2);
}
QT_WARNING_POP
