/****************************************************************************
** Meta object code from reading C++ file 'connection.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 "../../../libQuotient/Quotient/connection.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 'connection.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_ZN8Quotient10ConnectionE_t {};
} // unnamed namespace

template <> constexpr inline auto Quotient::Connection::qt_create_metaobjectdata<qt_meta_tag_ZN8Quotient10ConnectionE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Quotient::Connection",
        "resolveError",
        "",
        "error",
        "homeserverChanged",
        "QUrl",
        "baseUrl",
        "loginFlowsChanged",
        "capabilitiesLoaded",
        "connected",
        "loggedOut",
        "stateChanged",
        "isOnlineChanged",
        "loginError",
        "message",
        "details",
        "requestFailed",
        "Quotient::BaseJob*",
        "request",
        "networkError",
        "retriesTaken",
        "nextRetryInMilliseconds",
        "syncDone",
        "syncError",
        "newUser",
        "Quotient::User*",
        "user",
        "newRoom",
        "Quotient::Room*",
        "room",
        "invitedRoom",
        "prev",
        "joinedRoom",
        "leftRoom",
        "aboutToDeleteRoom",
        "createdRoom",
        "loadedRoomState",
        "accountDataChanged",
        "type",
        "directChatAvailable",
        "directChat",
        "directChatsListChanged",
        "Quotient::DirectChatsMap",
        "additions",
        "removals",
        "ignoredUsersListChanged",
        "Quotient::IgnoredUsersList",
        "cacheStateChanged",
        "lazyLoadingChanged",
        "turnServersChanged",
        "QJsonObject",
        "servers",
        "devicesListLoaded",
        "encryptionChanged",
        "enabled",
        "directChatsEncryptionChanged",
        "newKeyVerificationSession",
        "Quotient::KeyVerificationSession*",
        "session",
        "keyVerificationStateChanged",
        "const Quotient::KeyVerificationSession*",
        "Quotient::KeyVerificationSession::State",
        "state",
        "sessionVerified",
        "userId",
        "deviceId",
        "finishedQueryingKeys",
        "secretReceived",
        "requestId",
        "secret",
        "userVerified",
        "crossSigningSetupRequired",
        "ready",
        "loginWithPassword",
        "password",
        "initialDeviceName",
        "loginWithToken",
        "loginToken",
        "assumeIdentity",
        "mxId",
        "accessToken",
        "loadVersions",
        "JobHandle<GetVersionsJob>",
        "loadCapabilities",
        "JobHandle<GetCapabilitiesJob>",
        "reloadCapabilities",
        "logout",
        "QFuture<void>",
        "sync",
        "timeout",
        "syncLoop",
        "stopSync",
        "getThumbnail",
        "MediaThumbnailJob*",
        "mediaId",
        "QSize",
        "requestedSize",
        "RunningPolicy",
        "policy",
        "url",
        "requestedWidth",
        "requestedHeight",
        "uploadContent",
        "JobHandle<UploadContentJob>",
        "QIODevice*",
        "contentSource",
        "filename",
        "overrideContentType",
        "uploadFile",
        "fileName",
        "getContent",
        "BaseJob*",
        "downloadFile",
        "DownloadFileJob*",
        "localFilename",
        "EncryptedFileMetadata",
        "fileMetadata",
        "createRoom",
        "JobHandle<CreateRoomJob>",
        "RoomVisibility",
        "visibility",
        "alias",
        "name",
        "topic",
        "invites",
        "presetName",
        "roomVersion",
        "isDirect",
        "QList<CreateRoomJob::StateEvent>",
        "initialState",
        "QList<CreateRoomJob::Invite3pid>",
        "invite3pids",
        "creationContent",
        "additionalCreators",
        "QList<Invite3pid>",
        "requestDirectChat",
        "forgetRoom",
        "ForgetRoomJob*",
        "id",
        "sendToDevices",
        "SendToDeviceJob*",
        "eventType",
        "UsersToDevicesToContent",
        "contents",
        "sendMessage",
        "SendMessageJob*",
        "roomId",
        "RoomEvent",
        "event",
        "leaveRoom",
        "LeaveRoomJob*",
        "Room*",
        "startKeyVerificationSession",
        "startSelfVerification",
        "encryptionUpdate",
        "const Room*",
        "invitedIds",
        "makeMockConnection",
        "Connection*",
        "enableEncryption",
        "syncLoopIteration",
        "allRooms",
        "QList<Quotient::Room*>",
        "rooms",
        "Quotient::JoinStates",
        "joinStates",
        "roomsCount",
        "accountDataJson",
        "setAccountData",
        "content",
        "isIgnored",
        "const Quotient::User*",
        "ignoredUsers",
        "addToIgnoredUsers",
        "removeFromIgnoredUsers",
        "userIds",
        "getLoginFlow",
        "std::optional<LoginFlow>",
        "flowType",
        "states",
        "roomByAlias",
        "roomAlias",
        "invitation",
        "uId",
        "isQueryingKeys",
        "isUserVerified",
        "allSessionsSelfVerified",
        "syncJob",
        "Quotient::SyncJob*",
        "nextBatchToken",
        "millisToReconnect",
        "getTurnServers",
        "capabilitiesReady",
        "loadingCapabilities",
        "loadState",
        "saveState",
        "stateCachePath",
        "run",
        "job",
        "runningPolicy",
        "prepareForSso",
        "SsoSession*",
        "generateTxnId",
        "makeMediaUrl",
        "mxcUrl",
        "roomSucceeds",
        "maybePredecessorId",
        "maybeSuccessorId",
        "resolveServer",
        "mxid",
        "setHomeserver",
        "QFuture<QList<LoginFlow>>",
        "getDirectChat",
        "QFuture<Room*>",
        "otherUserId",
        "createDirectChat",
        "joinRoom",
        "JobHandle<JoinRoomJob>",
        "serverNames",
        "joinAndGetRoom",
        "waitForNewRoom",
        "localUser",
        "User*",
        "localUserId",
        "domain",
        "isLoggedIn",
        "isOnline",
        "defaultRoomVersion",
        "homeserver",
        "loginFlows",
        "QList<GetLoginFlowsJob::LoginFlow>",
        "isUsable",
        "supportsSso",
        "supportsPasswordAuth",
        "cacheState",
        "lazyLoading",
        "canChangePassword",
        "encryptionEnabled",
        "directChatEncryptionEnabled",
        "accountDataEventTypes"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'resolveError'
        QtMocHelpers::SignalData<void(QString)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'homeserverChanged'
        QtMocHelpers::SignalData<void(QUrl)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Signal 'loginFlowsChanged'
        QtMocHelpers::SignalData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'capabilitiesLoaded'
        QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'connected'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'loggedOut'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'stateChanged'
        QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'isOnlineChanged'
        QtMocHelpers::SignalData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'loginError'
        QtMocHelpers::SignalData<void(QString, QString)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 14 }, { QMetaType::QString, 15 },
        }}),
        // Signal 'requestFailed'
        QtMocHelpers::SignalData<void(Quotient::BaseJob *)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 17, 18 },
        }}),
        // Signal 'networkError'
        QtMocHelpers::SignalData<void(QString, QString, int, int)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 14 }, { QMetaType::QString, 15 }, { QMetaType::Int, 20 }, { QMetaType::Int, 21 },
        }}),
        // Signal 'syncDone'
        QtMocHelpers::SignalData<void()>(22, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'syncError'
        QtMocHelpers::SignalData<void(QString, QString)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 14 }, { QMetaType::QString, 15 },
        }}),
        // Signal 'newUser'
        QtMocHelpers::SignalData<void(Quotient::User *)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 26 },
        }}),
        // Signal 'newRoom'
        QtMocHelpers::SignalData<void(Quotient::Room *)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 28, 29 },
        }}),
        // Signal 'invitedRoom'
        QtMocHelpers::SignalData<void(Quotient::Room *, Quotient::Room *)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 28, 29 }, { 0x80000000 | 28, 31 },
        }}),
        // Signal 'joinedRoom'
        QtMocHelpers::SignalData<void(Quotient::Room *, Quotient::Room *)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 28, 29 }, { 0x80000000 | 28, 31 },
        }}),
        // Signal 'leftRoom'
        QtMocHelpers::SignalData<void(Quotient::Room *, Quotient::Room *)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 28, 29 }, { 0x80000000 | 28, 31 },
        }}),
        // Signal 'aboutToDeleteRoom'
        QtMocHelpers::SignalData<void(Quotient::Room *)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 28, 29 },
        }}),
        // Signal 'createdRoom'
        QtMocHelpers::SignalData<void(Quotient::Room *)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 28, 29 },
        }}),
        // Signal 'loadedRoomState'
        QtMocHelpers::SignalData<void(Quotient::Room *)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 28, 29 },
        }}),
        // Signal 'accountDataChanged'
        QtMocHelpers::SignalData<void(QString)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 38 },
        }}),
        // Signal 'directChatAvailable'
        QtMocHelpers::SignalData<void(Quotient::Room *)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 28, 40 },
        }}),
        // Signal 'directChatsListChanged'
        QtMocHelpers::SignalData<void(Quotient::DirectChatsMap, Quotient::DirectChatsMap)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 42, 43 }, { 0x80000000 | 42, 44 },
        }}),
        // Signal 'ignoredUsersListChanged'
        QtMocHelpers::SignalData<void(Quotient::IgnoredUsersList, Quotient::IgnoredUsersList)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 46, 43 }, { 0x80000000 | 46, 44 },
        }}),
        // Signal 'cacheStateChanged'
        QtMocHelpers::SignalData<void()>(47, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lazyLoadingChanged'
        QtMocHelpers::SignalData<void()>(48, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'turnServersChanged'
        QtMocHelpers::SignalData<void(const QJsonObject &)>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 50, 51 },
        }}),
        // Signal 'devicesListLoaded'
        QtMocHelpers::SignalData<void()>(52, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'encryptionChanged'
        QtMocHelpers::SignalData<void(bool)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 54 },
        }}),
        // Signal 'directChatsEncryptionChanged'
        QtMocHelpers::SignalData<void(bool)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 54 },
        }}),
        // Signal 'newKeyVerificationSession'
        QtMocHelpers::SignalData<void(Quotient::KeyVerificationSession *)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 57, 58 },
        }}),
        // Signal 'keyVerificationStateChanged'
        QtMocHelpers::SignalData<void(const Quotient::KeyVerificationSession *, Quotient::KeyVerificationSession::State)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 60, 58 }, { 0x80000000 | 61, 62 },
        }}),
        // Signal 'sessionVerified'
        QtMocHelpers::SignalData<void(const QString &, const QString &)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 64 }, { QMetaType::QString, 65 },
        }}),
        // Signal 'finishedQueryingKeys'
        QtMocHelpers::SignalData<void()>(66, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'secretReceived'
        QtMocHelpers::SignalData<void(const QString &, const QString &)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 68 }, { QMetaType::QString, 69 },
        }}),
        // Signal 'userVerified'
        QtMocHelpers::SignalData<void(const QString &)>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 64 },
        }}),
        // Signal 'crossSigningSetupRequired'
        QtMocHelpers::SignalData<void()>(71, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'ready'
        QtMocHelpers::SignalData<void()>(72, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'loginWithPassword'
        QtMocHelpers::SlotData<void(const QString &, const QString &, const QString &, const QString &)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 64 }, { QMetaType::QString, 74 }, { QMetaType::QString, 75 }, { QMetaType::QString, 65 },
        }}),
        // Slot 'loginWithPassword'
        QtMocHelpers::SlotData<void(const QString &, const QString &, const QString &)>(73, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 64 }, { QMetaType::QString, 74 }, { QMetaType::QString, 75 },
        }}),
        // Slot 'loginWithToken'
        QtMocHelpers::SlotData<void(const QString &, const QString &, const QString &)>(76, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 77 }, { QMetaType::QString, 75 }, { QMetaType::QString, 65 },
        }}),
        // Slot 'loginWithToken'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(76, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 77 }, { QMetaType::QString, 75 },
        }}),
        // Slot 'assumeIdentity'
        QtMocHelpers::SlotData<void(const QString &, const QString &, const QString &)>(78, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 79 }, { QMetaType::QString, 65 }, { QMetaType::QString, 80 },
        }}),
        // Slot 'loadVersions'
        QtMocHelpers::SlotData<JobHandle<GetVersionsJob>()>(81, 2, QMC::AccessPublic, 0x80000000 | 82),
        // Slot 'loadCapabilities'
        QtMocHelpers::SlotData<JobHandle<GetCapabilitiesJob>()>(83, 2, QMC::AccessPublic, 0x80000000 | 84),
        // Slot 'reloadCapabilities'
        QtMocHelpers::SlotData<void()>(85, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'logout'
        QtMocHelpers::SlotData<QFuture<void>()>(86, 2, QMC::AccessPublic, 0x80000000 | 87),
        // Slot 'sync'
        QtMocHelpers::SlotData<void(int)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 89 },
        }}),
        // Slot 'sync'
        QtMocHelpers::SlotData<void()>(88, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'syncLoop'
        QtMocHelpers::SlotData<void(int)>(90, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 89 },
        }}),
        // Slot 'syncLoop'
        QtMocHelpers::SlotData<void()>(90, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'stopSync'
        QtMocHelpers::SlotData<void()>(91, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'getThumbnail'
        QtMocHelpers::SlotData<MediaThumbnailJob *(const QString &, QSize, RunningPolicy)>(92, 2, QMC::AccessPublic, 0x80000000 | 93, {{
            { QMetaType::QString, 94 }, { 0x80000000 | 95, 96 }, { 0x80000000 | 97, 98 },
        }}),
        // Slot 'getThumbnail'
        QtMocHelpers::SlotData<MediaThumbnailJob *(const QString &, QSize)>(92, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 93, {{
            { QMetaType::QString, 94 }, { 0x80000000 | 95, 96 },
        }}),
        // Slot 'getThumbnail'
        QtMocHelpers::SlotData<MediaThumbnailJob *(const QUrl &, QSize, RunningPolicy)>(92, 2, QMC::AccessPublic, 0x80000000 | 93, {{
            { 0x80000000 | 5, 99 }, { 0x80000000 | 95, 96 }, { 0x80000000 | 97, 98 },
        }}),
        // Slot 'getThumbnail'
        QtMocHelpers::SlotData<MediaThumbnailJob *(const QUrl &, QSize)>(92, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 93, {{
            { 0x80000000 | 5, 99 }, { 0x80000000 | 95, 96 },
        }}),
        // Slot 'getThumbnail'
        QtMocHelpers::SlotData<MediaThumbnailJob *(const QUrl &, int, int, RunningPolicy)>(92, 2, QMC::AccessPublic, 0x80000000 | 93, {{
            { 0x80000000 | 5, 99 }, { QMetaType::Int, 100 }, { QMetaType::Int, 101 }, { 0x80000000 | 97, 98 },
        }}),
        // Slot 'getThumbnail'
        QtMocHelpers::SlotData<MediaThumbnailJob *(const QUrl &, int, int)>(92, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 93, {{
            { 0x80000000 | 5, 99 }, { QMetaType::Int, 100 }, { QMetaType::Int, 101 },
        }}),
        // Slot 'uploadContent'
        QtMocHelpers::SlotData<JobHandle<UploadContentJob>(QIODevice *, const QString &, const QString &)>(102, 2, QMC::AccessPublic, 0x80000000 | 103, {{
            { 0x80000000 | 104, 105 }, { QMetaType::QString, 106 }, { QMetaType::QString, 107 },
        }}),
        // Slot 'uploadContent'
        QtMocHelpers::SlotData<JobHandle<UploadContentJob>(QIODevice *, const QString &)>(102, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 103, {{
            { 0x80000000 | 104, 105 }, { QMetaType::QString, 106 },
        }}),
        // Slot 'uploadContent'
        QtMocHelpers::SlotData<JobHandle<UploadContentJob>(QIODevice *)>(102, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 103, {{
            { 0x80000000 | 104, 105 },
        }}),
        // Slot 'uploadFile'
        QtMocHelpers::SlotData<JobHandle<UploadContentJob>(const QString &, const QString &)>(108, 2, QMC::AccessPublic, 0x80000000 | 103, {{
            { QMetaType::QString, 109 }, { QMetaType::QString, 107 },
        }}),
        // Slot 'uploadFile'
        QtMocHelpers::SlotData<JobHandle<UploadContentJob>(const QString &)>(108, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 103, {{
            { QMetaType::QString, 109 },
        }}),
        // Slot 'getContent'
        QtMocHelpers::SlotData<BaseJob *(const QString &)>(110, 2, QMC::AccessPublic, 0x80000000 | 111, {{
            { QMetaType::QString, 94 },
        }}),
        // Slot 'getContent'
        QtMocHelpers::SlotData<BaseJob *(const QUrl &)>(110, 2, QMC::AccessPublic, 0x80000000 | 111, {{
            { 0x80000000 | 5, 99 },
        }}),
        // Slot 'downloadFile'
        QtMocHelpers::SlotData<DownloadFileJob *(const QUrl &, const QString &)>(112, 2, QMC::AccessPublic, 0x80000000 | 113, {{
            { 0x80000000 | 5, 99 }, { QMetaType::QString, 114 },
        }}),
        // Slot 'downloadFile'
        QtMocHelpers::SlotData<DownloadFileJob *(const QUrl &)>(112, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 113, {{
            { 0x80000000 | 5, 99 },
        }}),
        // Slot 'downloadFile'
        QtMocHelpers::SlotData<DownloadFileJob *(const QUrl &, const EncryptedFileMetadata &, const QString &)>(112, 2, QMC::AccessPublic, 0x80000000 | 113, {{
            { 0x80000000 | 5, 99 }, { 0x80000000 | 115, 116 }, { QMetaType::QString, 114 },
        }}),
        // Slot 'downloadFile'
        QtMocHelpers::SlotData<DownloadFileJob *(const QUrl &, const EncryptedFileMetadata &)>(112, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 113, {{
            { 0x80000000 | 5, 99 }, { 0x80000000 | 115, 116 },
        }}),
        // Slot 'createRoom'
        QtMocHelpers::SlotData<JobHandle<CreateRoomJob>(enum RoomVisibility, const QString &, const QString &, const QString &, QStringList, const QString &, const QString &, bool, const QVector<CreateRoomJob::StateEvent> &, const QVector<CreateRoomJob::Invite3pid> &, const QJsonObject &)>(117, 2, QMC::AccessPublic, 0x80000000 | 118, {{
            { 0x80000000 | 119, 120 }, { QMetaType::QString, 121 }, { QMetaType::QString, 122 }, { QMetaType::QString, 123 },
            { QMetaType::QStringList, 124 }, { QMetaType::QString, 125 }, { QMetaType::QString, 126 }, { QMetaType::Bool, 127 },
            { 0x80000000 | 128, 129 }, { 0x80000000 | 130, 131 }, { 0x80000000 | 50, 132 },
        }}),
        // Slot 'createRoom'
        QtMocHelpers::SlotData<JobHandle<CreateRoomJob>(enum RoomVisibility, const QString &, const QString &, const QString &, QStringList, const QString &, const QString &, bool, const QVector<CreateRoomJob::StateEvent> &, const QVector<CreateRoomJob::Invite3pid> &)>(117, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 118, {{
            { 0x80000000 | 119, 120 }, { QMetaType::QString, 121 }, { QMetaType::QString, 122 }, { QMetaType::QString, 123 },
            { QMetaType::QStringList, 124 }, { QMetaType::QString, 125 }, { QMetaType::QString, 126 }, { QMetaType::Bool, 127 },
            { 0x80000000 | 128, 129 }, { 0x80000000 | 130, 131 },
        }}),
        // Slot 'createRoom'
        QtMocHelpers::SlotData<JobHandle<CreateRoomJob>(enum RoomVisibility, const QString &, const QString &, const QString &, QStringList, const QString &, const QString &, bool, const QVector<CreateRoomJob::StateEvent> &)>(117, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 118, {{
            { 0x80000000 | 119, 120 }, { QMetaType::QString, 121 }, { QMetaType::QString, 122 }, { QMetaType::QString, 123 },
            { QMetaType::QStringList, 124 }, { QMetaType::QString, 125 }, { QMetaType::QString, 126 }, { QMetaType::Bool, 127 },
            { 0x80000000 | 128, 129 },
        }}),
        // Slot 'createRoom'
        QtMocHelpers::SlotData<JobHandle<CreateRoomJob>(enum RoomVisibility, const QString &, const QString &, const QString &, QStringList, const QString &, const QString &, bool)>(117, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 118, {{
            { 0x80000000 | 119, 120 }, { QMetaType::QString, 121 }, { QMetaType::QString, 122 }, { QMetaType::QString, 123 },
            { QMetaType::QStringList, 124 }, { QMetaType::QString, 125 }, { QMetaType::QString, 126 }, { QMetaType::Bool, 127 },
        }}),
        // Slot 'createRoom'
        QtMocHelpers::SlotData<JobHandle<CreateRoomJob>(enum RoomVisibility, const QString &, const QString &, const QString &, QStringList, const QString &, const QString &)>(117, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 118, {{
            { 0x80000000 | 119, 120 }, { QMetaType::QString, 121 }, { QMetaType::QString, 122 }, { QMetaType::QString, 123 },
            { QMetaType::QStringList, 124 }, { QMetaType::QString, 125 }, { QMetaType::QString, 126 },
        }}),
        // Slot 'createRoom'
        QtMocHelpers::SlotData<JobHandle<CreateRoomJob>(enum RoomVisibility, const QString &, const QString &, const QString &, QStringList, const QString &)>(117, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 118, {{
            { 0x80000000 | 119, 120 }, { QMetaType::QString, 121 }, { QMetaType::QString, 122 }, { QMetaType::QString, 123 },
            { QMetaType::QStringList, 124 }, { QMetaType::QString, 125 },
        }}),
        // Slot 'createRoom'
        QtMocHelpers::SlotData<JobHandle<CreateRoomJob>(enum RoomVisibility, const QString &, const QString &, const QString &, QStringList)>(117, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 118, {{
            { 0x80000000 | 119, 120 }, { QMetaType::QString, 121 }, { QMetaType::QString, 122 }, { QMetaType::QString, 123 },
            { QMetaType::QStringList, 124 },
        }}),
        // Slot 'createRoom'
        QtMocHelpers::SlotData<JobHandle<CreateRoomJob>(enum RoomVisibility, const QString &, const QString &, const QString &, QStringList, const QString &, const QString &, bool, const QVector<CreateRoomJob::StateEvent> &, const QStringList &, const QVector<Invite3pid> &, QJsonObject)>(117, 2, QMC::AccessPublic, 0x80000000 | 118, {{
            { 0x80000000 | 119, 120 }, { QMetaType::QString, 121 }, { QMetaType::QString, 122 }, { QMetaType::QString, 123 },
            { QMetaType::QStringList, 124 }, { QMetaType::QString, 125 }, { QMetaType::QString, 126 }, { QMetaType::Bool, 127 },
            { 0x80000000 | 128, 129 }, { QMetaType::QStringList, 133 }, { 0x80000000 | 134, 131 }, { 0x80000000 | 50, 132 },
        }}),
        // Slot 'createRoom'
        QtMocHelpers::SlotData<JobHandle<CreateRoomJob>(enum RoomVisibility, const QString &, const QString &, const QString &, QStringList, const QString &, const QString &, bool, const QVector<CreateRoomJob::StateEvent> &, const QStringList &, const QVector<Invite3pid> &)>(117, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 118, {{
            { 0x80000000 | 119, 120 }, { QMetaType::QString, 121 }, { QMetaType::QString, 122 }, { QMetaType::QString, 123 },
            { QMetaType::QStringList, 124 }, { QMetaType::QString, 125 }, { QMetaType::QString, 126 }, { QMetaType::Bool, 127 },
            { 0x80000000 | 128, 129 }, { QMetaType::QStringList, 133 }, { 0x80000000 | 134, 131 },
        }}),
        // Slot 'createRoom'
        QtMocHelpers::SlotData<JobHandle<CreateRoomJob>(enum RoomVisibility, const QString &, const QString &, const QString &, QStringList, const QString &, const QString &, bool, const QVector<CreateRoomJob::StateEvent> &, const QStringList &)>(117, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 118, {{
            { 0x80000000 | 119, 120 }, { QMetaType::QString, 121 }, { QMetaType::QString, 122 }, { QMetaType::QString, 123 },
            { QMetaType::QStringList, 124 }, { QMetaType::QString, 125 }, { QMetaType::QString, 126 }, { QMetaType::Bool, 127 },
            { 0x80000000 | 128, 129 }, { QMetaType::QStringList, 133 },
        }}),
        // Slot 'requestDirectChat'
        QtMocHelpers::SlotData<void(const QString &)>(135, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 64 },
        }}),
        // Slot 'forgetRoom'
        QtMocHelpers::SlotData<ForgetRoomJob *(const QString &)>(136, 2, QMC::AccessPublic, 0x80000000 | 137, {{
            { QMetaType::QString, 138 },
        }}),
        // Slot 'sendToDevices'
        QtMocHelpers::SlotData<SendToDeviceJob *(const QString &, const UsersToDevicesToContent &)>(139, 2, QMC::AccessPublic, 0x80000000 | 140, {{
            { QMetaType::QString, 141 }, { 0x80000000 | 142, 143 },
        }}),
        // Slot 'sendMessage'
        QtMocHelpers::SlotData<SendMessageJob *(const QString &, const RoomEvent &)>(144, 2, QMC::AccessPublic, 0x80000000 | 145, {{
            { QMetaType::QString, 146 }, { 0x80000000 | 147, 148 },
        }}),
        // Slot 'leaveRoom'
        QtMocHelpers::SlotData<LeaveRoomJob *(Room *)>(149, 2, QMC::AccessPublic, 0x80000000 | 150, {{
            { 0x80000000 | 151, 29 },
        }}),
        // Slot 'startKeyVerificationSession'
        QtMocHelpers::SlotData<Quotient::KeyVerificationSession *(const QString &, const QString &)>(152, 2, QMC::AccessPublic, 0x80000000 | 57, {{
            { QMetaType::QString, 64 }, { QMetaType::QString, 65 },
        }}),
        // Slot 'startSelfVerification'
        QtMocHelpers::SlotData<void()>(153, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'encryptionUpdate'
        QtMocHelpers::SlotData<void(const Room *, const QStringList &)>(154, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 155, 29 }, { QMetaType::QStringList, 156 },
        }}),
        // Slot 'encryptionUpdate'
        QtMocHelpers::SlotData<void(const Room *)>(154, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 155, 29 },
        }}),
        // Slot 'makeMockConnection'
        QtMocHelpers::SlotData<Connection *(const QString &, bool)>(157, 2, QMC::AccessPublic, 0x80000000 | 158, {{
            { QMetaType::QString, 79 }, { QMetaType::Bool, 159 },
        }}),
        // Slot 'makeMockConnection'
        QtMocHelpers::SlotData<Connection *(const QString &)>(157, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 158, {{
            { QMetaType::QString, 79 },
        }}),
        // Slot 'syncLoopIteration'
        QtMocHelpers::SlotData<void()>(160, 2, QMC::AccessProtected, QMetaType::Void),
        // Method 'allRooms'
        QtMocHelpers::MethodData<QVector<Quotient::Room*>() const>(161, 2, QMC::AccessPublic, 0x80000000 | 162),
        // Method 'rooms'
        QtMocHelpers::MethodData<QVector<Quotient::Room*>(Quotient::JoinStates) const>(163, 2, QMC::AccessPublic, 0x80000000 | 162, {{
            { 0x80000000 | 164, 165 },
        }}),
        // Method 'roomsCount'
        QtMocHelpers::MethodData<int(Quotient::JoinStates) const>(166, 2, QMC::AccessPublic, QMetaType::Int, {{
            { 0x80000000 | 164, 165 },
        }}),
        // Method 'accountDataJson'
        QtMocHelpers::MethodData<QJsonObject(const QString &) const>(167, 2, QMC::AccessPublic, 0x80000000 | 50, {{
            { QMetaType::QString, 38 },
        }}),
        // Method 'setAccountData'
        QtMocHelpers::MethodData<void(const QString &, const QJsonObject &)>(168, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 38 }, { 0x80000000 | 50, 169 },
        }}),
        // Method 'isIgnored'
        QtMocHelpers::MethodData<bool(const QString &) const>(170, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 64 },
        }}),
        // Method 'isIgnored'
        QtMocHelpers::MethodData<bool(const Quotient::User *) const>(170, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 171, 26 },
        }}),
        // Method 'ignoredUsers'
        QtMocHelpers::MethodData<Quotient::IgnoredUsersList() const>(172, 2, QMC::AccessPublic, 0x80000000 | 46),
        // Method 'addToIgnoredUsers'
        QtMocHelpers::MethodData<void(const QString &)>(173, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 64 },
        }}),
        // Method 'removeFromIgnoredUsers'
        QtMocHelpers::MethodData<void(const QString &)>(174, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 64 },
        }}),
        // Method 'userIds'
        QtMocHelpers::MethodData<QStringList() const>(175, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'getLoginFlow'
        QtMocHelpers::MethodData<std::optional<LoginFlow>(const QString &) const>(176, 2, QMC::AccessPublic, 0x80000000 | 177, {{
            { QMetaType::QString, 178 },
        }}),
        // Method 'room'
        QtMocHelpers::MethodData<Quotient::Room *(const QString &, Quotient::JoinStates) const>(29, 2, QMC::AccessPublic, 0x80000000 | 28, {{
            { QMetaType::QString, 146 }, { 0x80000000 | 164, 179 },
        }}),
        // Method 'room'
        QtMocHelpers::MethodData<Quotient::Room *(const QString &) const>(29, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 28, {{
            { QMetaType::QString, 146 },
        }}),
        // Method 'roomByAlias'
        QtMocHelpers::MethodData<Quotient::Room *(const QString &, Quotient::JoinStates) const>(180, 2, QMC::AccessPublic, 0x80000000 | 28, {{
            { QMetaType::QString, 181 }, { 0x80000000 | 164, 179 },
        }}),
        // Method 'roomByAlias'
        QtMocHelpers::MethodData<Quotient::Room *(const QString &) const>(180, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 28, {{
            { QMetaType::QString, 181 },
        }}),
        // Method 'invitation'
        QtMocHelpers::MethodData<Quotient::Room *(const QString &) const>(182, 2, QMC::AccessPublic, 0x80000000 | 28, {{
            { QMetaType::QString, 146 },
        }}),
        // Method 'user'
        QtMocHelpers::MethodData<Quotient::User *(const QString &)>(26, 2, QMC::AccessPublic, 0x80000000 | 25, {{
            { QMetaType::QString, 183 },
        }}),
        // Method 'isQueryingKeys'
        QtMocHelpers::MethodData<bool() const>(184, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'isUserVerified'
        QtMocHelpers::MethodData<bool(const QString &) const>(185, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 64 },
        }}),
        // Method 'allSessionsSelfVerified'
        QtMocHelpers::MethodData<bool(const QString &) const>(186, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 64 },
        }}),
        // Method 'syncJob'
        QtMocHelpers::MethodData<Quotient::SyncJob *() const>(187, 2, QMC::AccessPublic, 0x80000000 | 188),
        // Method 'nextBatchToken'
        QtMocHelpers::MethodData<QString() const>(189, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'millisToReconnect'
        QtMocHelpers::MethodData<int() const>(190, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'getTurnServers'
        QtMocHelpers::MethodData<void()>(191, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'capabilitiesReady'
        QtMocHelpers::MethodData<bool() const>(192, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'loadingCapabilities'
        QtMocHelpers::MethodData<bool() const>(193, 2, QMC::AccessPublic, QMetaType::Bool),
        // Method 'loadState'
        QtMocHelpers::MethodData<void()>(194, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'saveState'
        QtMocHelpers::MethodData<void() const>(195, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'stateCachePath'
        QtMocHelpers::MethodData<QString() const>(196, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'run'
        QtMocHelpers::MethodData<BaseJob *(BaseJob *, RunningPolicy)>(197, 2, QMC::AccessPublic, 0x80000000 | 111, {{
            { 0x80000000 | 111, 198 }, { 0x80000000 | 97, 199 },
        }}),
        // Method 'run'
        QtMocHelpers::MethodData<BaseJob *(BaseJob *)>(197, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 111, {{
            { 0x80000000 | 111, 198 },
        }}),
        // Method 'prepareForSso'
        QtMocHelpers::MethodData<SsoSession *(const QString &, const QString &)>(200, 2, QMC::AccessPublic, 0x80000000 | 201, {{
            { QMetaType::QString, 75 }, { QMetaType::QString, 65 },
        }}),
        // Method 'prepareForSso'
        QtMocHelpers::MethodData<SsoSession *(const QString &)>(200, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 201, {{
            { QMetaType::QString, 75 },
        }}),
        // Method 'generateTxnId'
        QtMocHelpers::MethodData<QString() const>(202, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'makeMediaUrl'
        QtMocHelpers::MethodData<QUrl(QUrl) const>(203, 2, QMC::AccessPublic, 0x80000000 | 5, {{
            { 0x80000000 | 5, 204 },
        }}),
        // Method 'roomSucceeds'
        QtMocHelpers::MethodData<bool(const QString &, const QString &) const>(205, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 206 }, { QMetaType::QString, 207 },
        }}),
        // Method 'resolveServer'
        QtMocHelpers::MethodData<void(const QString &)>(208, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 209 },
        }}),
        // Method 'setHomeserver'
        QtMocHelpers::MethodData<QFuture<QList<LoginFlow> >(const QUrl &)>(210, 2, QMC::AccessPublic, 0x80000000 | 211, {{
            { 0x80000000 | 5, 6 },
        }}),
        // Method 'getDirectChat'
        QtMocHelpers::MethodData<QFuture<Room*>(const QString &)>(212, 2, QMC::AccessPublic, 0x80000000 | 213, {{
            { QMetaType::QString, 214 },
        }}),
        // Method 'createDirectChat'
        QtMocHelpers::MethodData<JobHandle<CreateRoomJob>(const QString &, const QString &, const QString &)>(215, 2, QMC::AccessPublic, 0x80000000 | 118, {{
            { QMetaType::QString, 64 }, { QMetaType::QString, 123 }, { QMetaType::QString, 122 },
        }}),
        // Method 'createDirectChat'
        QtMocHelpers::MethodData<JobHandle<CreateRoomJob>(const QString &, const QString &)>(215, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 118, {{
            { QMetaType::QString, 64 }, { QMetaType::QString, 123 },
        }}),
        // Method 'createDirectChat'
        QtMocHelpers::MethodData<JobHandle<CreateRoomJob>(const QString &)>(215, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 118, {{
            { QMetaType::QString, 64 },
        }}),
        // Method 'joinRoom'
        QtMocHelpers::MethodData<JobHandle<JoinRoomJob>(const QString &, const QStringList &)>(216, 2, QMC::AccessPublic, 0x80000000 | 217, {{
            { QMetaType::QString, 181 }, { QMetaType::QStringList, 218 },
        }}),
        // Method 'joinRoom'
        QtMocHelpers::MethodData<JobHandle<JoinRoomJob>(const QString &)>(216, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 217, {{
            { QMetaType::QString, 181 },
        }}),
        // Method 'joinAndGetRoom'
        QtMocHelpers::MethodData<QFuture<Room*>(const QString &, const QStringList &)>(219, 2, QMC::AccessPublic, 0x80000000 | 213, {{
            { QMetaType::QString, 181 }, { QMetaType::QStringList, 218 },
        }}),
        // Method 'joinAndGetRoom'
        QtMocHelpers::MethodData<QFuture<Room*>(const QString &)>(219, 2, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 213, {{
            { QMetaType::QString, 181 },
        }}),
        // Method 'waitForNewRoom'
        QtMocHelpers::MethodData<QFuture<Room*>(const QString &)>(220, 2, QMC::AccessPublic, 0x80000000 | 213, {{
            { QMetaType::QString, 146 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'localUser'
        QtMocHelpers::PropertyData<User*>(221, 0x80000000 | 222, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 6),
        // property 'localUserId'
        QtMocHelpers::PropertyData<QString>(223, QMetaType::QString, QMC::DefaultPropertyFlags, 6),
        // property 'domain'
        QtMocHelpers::PropertyData<QString>(224, QMetaType::QString, QMC::Readable | QMC::Designable | QMC::Scriptable, 6),
        // property 'deviceId'
        QtMocHelpers::PropertyData<QString>(65, QMetaType::QString, QMC::DefaultPropertyFlags, 6),
        // property 'accessToken'
        QtMocHelpers::PropertyData<QByteArray>(80, QMetaType::QByteArray, QMC::DefaultPropertyFlags, 6),
        // property 'isLoggedIn'
        QtMocHelpers::PropertyData<bool>(225, QMetaType::Bool, QMC::Readable | QMC::Designable | QMC::Scriptable, 6),
        // property 'isOnline'
        QtMocHelpers::PropertyData<bool>(226, QMetaType::Bool, QMC::DefaultPropertyFlags, 7),
        // property 'defaultRoomVersion'
        QtMocHelpers::PropertyData<QString>(227, QMetaType::QString, QMC::DefaultPropertyFlags, 3),
        // property 'homeserver'
        QtMocHelpers::PropertyData<QUrl>(228, 0x80000000 | 5, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 1),
        // property 'loginFlows'
        QtMocHelpers::PropertyData<QList<GetLoginFlowsJob::LoginFlow>>(229, 0x80000000 | 230, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 2),
        // property 'isUsable'
        QtMocHelpers::PropertyData<bool>(231, QMetaType::Bool, QMC::Readable | QMC::Designable | QMC::Scriptable, 2),
        // property 'supportsSso'
        QtMocHelpers::PropertyData<bool>(232, QMetaType::Bool, QMC::Readable | QMC::Designable | QMC::Scriptable, 2),
        // property 'supportsPasswordAuth'
        QtMocHelpers::PropertyData<bool>(233, QMetaType::Bool, QMC::Readable | QMC::Designable | QMC::Scriptable, 2),
        // property 'cacheState'
        QtMocHelpers::PropertyData<bool>(234, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 25),
        // property 'lazyLoading'
        QtMocHelpers::PropertyData<bool>(235, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 26),
        // property 'canChangePassword'
        QtMocHelpers::PropertyData<bool>(236, QMetaType::Bool, QMC::DefaultPropertyFlags, 3),
        // property 'encryptionEnabled'
        QtMocHelpers::PropertyData<bool>(237, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 29),
        // property 'directChatEncryptionEnabled'
        QtMocHelpers::PropertyData<bool>(238, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable, 30),
        // property 'accountDataEventTypes'
        QtMocHelpers::PropertyData<QStringList>(239, QMetaType::QStringList, QMC::DefaultPropertyFlags, 21),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Connection, qt_meta_tag_ZN8Quotient10ConnectionE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Quotient::Connection::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Quotient10ConnectionE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN8Quotient10ConnectionE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN8Quotient10ConnectionE_t>.metaTypes,
    nullptr
} };

void Quotient::Connection::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Connection *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->resolveError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->homeserverChanged((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 2: _t->loginFlowsChanged(); break;
        case 3: _t->capabilitiesLoaded(); break;
        case 4: _t->connected(); break;
        case 5: _t->loggedOut(); break;
        case 6: _t->stateChanged(); break;
        case 7: _t->isOnlineChanged(); break;
        case 8: _t->loginError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 9: _t->requestFailed((*reinterpret_cast<std::add_pointer_t<Quotient::BaseJob*>>(_a[1]))); break;
        case 10: _t->networkError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4]))); break;
        case 11: _t->syncDone(); break;
        case 12: _t->syncError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 13: _t->newUser((*reinterpret_cast<std::add_pointer_t<Quotient::User*>>(_a[1]))); break;
        case 14: _t->newRoom((*reinterpret_cast<std::add_pointer_t<Quotient::Room*>>(_a[1]))); break;
        case 15: _t->invitedRoom((*reinterpret_cast<std::add_pointer_t<Quotient::Room*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Quotient::Room*>>(_a[2]))); break;
        case 16: _t->joinedRoom((*reinterpret_cast<std::add_pointer_t<Quotient::Room*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Quotient::Room*>>(_a[2]))); break;
        case 17: _t->leftRoom((*reinterpret_cast<std::add_pointer_t<Quotient::Room*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Quotient::Room*>>(_a[2]))); break;
        case 18: _t->aboutToDeleteRoom((*reinterpret_cast<std::add_pointer_t<Quotient::Room*>>(_a[1]))); break;
        case 19: _t->createdRoom((*reinterpret_cast<std::add_pointer_t<Quotient::Room*>>(_a[1]))); break;
        case 20: _t->loadedRoomState((*reinterpret_cast<std::add_pointer_t<Quotient::Room*>>(_a[1]))); break;
        case 21: _t->accountDataChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 22: _t->directChatAvailable((*reinterpret_cast<std::add_pointer_t<Quotient::Room*>>(_a[1]))); break;
        case 23: _t->directChatsListChanged((*reinterpret_cast<std::add_pointer_t<Quotient::DirectChatsMap>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Quotient::DirectChatsMap>>(_a[2]))); break;
        case 24: _t->ignoredUsersListChanged((*reinterpret_cast<std::add_pointer_t<Quotient::IgnoredUsersList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Quotient::IgnoredUsersList>>(_a[2]))); break;
        case 25: _t->cacheStateChanged(); break;
        case 26: _t->lazyLoadingChanged(); break;
        case 27: _t->turnServersChanged((*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[1]))); break;
        case 28: _t->devicesListLoaded(); break;
        case 29: _t->encryptionChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 30: _t->directChatsEncryptionChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 31: _t->newKeyVerificationSession((*reinterpret_cast<std::add_pointer_t<Quotient::KeyVerificationSession*>>(_a[1]))); break;
        case 32: _t->keyVerificationStateChanged((*reinterpret_cast<std::add_pointer_t<const Quotient::KeyVerificationSession*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Quotient::KeyVerificationSession::State>>(_a[2]))); break;
        case 33: _t->sessionVerified((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 34: _t->finishedQueryingKeys(); break;
        case 35: _t->secretReceived((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 36: _t->userVerified((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 37: _t->crossSigningSetupRequired(); break;
        case 38: _t->ready(); break;
        case 39: _t->loginWithPassword((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4]))); break;
        case 40: _t->loginWithPassword((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 41: _t->loginWithToken((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 42: _t->loginWithToken((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 43: _t->assumeIdentity((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 44: { JobHandle<GetVersionsJob> _r = _t->loadVersions();
            if (_a[0]) *reinterpret_cast<JobHandle<GetVersionsJob>*>(_a[0]) = std::move(_r); }  break;
        case 45: { JobHandle<GetCapabilitiesJob> _r = _t->loadCapabilities();
            if (_a[0]) *reinterpret_cast<JobHandle<GetCapabilitiesJob>*>(_a[0]) = std::move(_r); }  break;
        case 46: _t->reloadCapabilities(); break;
        case 47: { QFuture<void> _r = _t->logout();
            if (_a[0]) *reinterpret_cast<QFuture<void>*>(_a[0]) = std::move(_r); }  break;
        case 48: _t->sync((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 49: _t->sync(); break;
        case 50: _t->syncLoop((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 51: _t->syncLoop(); break;
        case 52: _t->stopSync(); break;
        case 53: { MediaThumbnailJob* _r = _t->getThumbnail((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QSize>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<RunningPolicy>>(_a[3])));
            if (_a[0]) *reinterpret_cast<MediaThumbnailJob**>(_a[0]) = std::move(_r); }  break;
        case 54: { MediaThumbnailJob* _r = _t->getThumbnail((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QSize>>(_a[2])));
            if (_a[0]) *reinterpret_cast<MediaThumbnailJob**>(_a[0]) = std::move(_r); }  break;
        case 55: { MediaThumbnailJob* _r = _t->getThumbnail((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QSize>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<RunningPolicy>>(_a[3])));
            if (_a[0]) *reinterpret_cast<MediaThumbnailJob**>(_a[0]) = std::move(_r); }  break;
        case 56: { MediaThumbnailJob* _r = _t->getThumbnail((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QSize>>(_a[2])));
            if (_a[0]) *reinterpret_cast<MediaThumbnailJob**>(_a[0]) = std::move(_r); }  break;
        case 57: { MediaThumbnailJob* _r = _t->getThumbnail((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<RunningPolicy>>(_a[4])));
            if (_a[0]) *reinterpret_cast<MediaThumbnailJob**>(_a[0]) = std::move(_r); }  break;
        case 58: { MediaThumbnailJob* _r = _t->getThumbnail((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<MediaThumbnailJob**>(_a[0]) = std::move(_r); }  break;
        case 59: { JobHandle<UploadContentJob> _r = _t->uploadContent((*reinterpret_cast<std::add_pointer_t<QIODevice*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<JobHandle<UploadContentJob>*>(_a[0]) = std::move(_r); }  break;
        case 60: { JobHandle<UploadContentJob> _r = _t->uploadContent((*reinterpret_cast<std::add_pointer_t<QIODevice*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<JobHandle<UploadContentJob>*>(_a[0]) = std::move(_r); }  break;
        case 61: { JobHandle<UploadContentJob> _r = _t->uploadContent((*reinterpret_cast<std::add_pointer_t<QIODevice*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<JobHandle<UploadContentJob>*>(_a[0]) = std::move(_r); }  break;
        case 62: { JobHandle<UploadContentJob> _r = _t->uploadFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<JobHandle<UploadContentJob>*>(_a[0]) = std::move(_r); }  break;
        case 63: { JobHandle<UploadContentJob> _r = _t->uploadFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<JobHandle<UploadContentJob>*>(_a[0]) = std::move(_r); }  break;
        case 64: { BaseJob* _r = _t->getContent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<BaseJob**>(_a[0]) = std::move(_r); }  break;
        case 65: { BaseJob* _r = _t->getContent((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])));
            if (_a[0]) *reinterpret_cast<BaseJob**>(_a[0]) = std::move(_r); }  break;
        case 66: { DownloadFileJob* _r = _t->downloadFile((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<DownloadFileJob**>(_a[0]) = std::move(_r); }  break;
        case 67: { DownloadFileJob* _r = _t->downloadFile((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])));
            if (_a[0]) *reinterpret_cast<DownloadFileJob**>(_a[0]) = std::move(_r); }  break;
        case 68: { DownloadFileJob* _r = _t->downloadFile((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<EncryptedFileMetadata>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<DownloadFileJob**>(_a[0]) = std::move(_r); }  break;
        case 69: { DownloadFileJob* _r = _t->downloadFile((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<EncryptedFileMetadata>>(_a[2])));
            if (_a[0]) *reinterpret_cast<DownloadFileJob**>(_a[0]) = std::move(_r); }  break;
        case 70: { JobHandle<CreateRoomJob> _r = _t->createRoom((*reinterpret_cast<std::add_pointer_t<enum RoomVisibility>>(_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])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[8])),(*reinterpret_cast<std::add_pointer_t<QList<CreateRoomJob::StateEvent>>>(_a[9])),(*reinterpret_cast<std::add_pointer_t<QList<CreateRoomJob::Invite3pid>>>(_a[10])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[11])));
            if (_a[0]) *reinterpret_cast<JobHandle<CreateRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 71: { JobHandle<CreateRoomJob> _r = _t->createRoom((*reinterpret_cast<std::add_pointer_t<enum RoomVisibility>>(_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])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[8])),(*reinterpret_cast<std::add_pointer_t<QList<CreateRoomJob::StateEvent>>>(_a[9])),(*reinterpret_cast<std::add_pointer_t<QList<CreateRoomJob::Invite3pid>>>(_a[10])));
            if (_a[0]) *reinterpret_cast<JobHandle<CreateRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 72: { JobHandle<CreateRoomJob> _r = _t->createRoom((*reinterpret_cast<std::add_pointer_t<enum RoomVisibility>>(_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])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[8])),(*reinterpret_cast<std::add_pointer_t<QList<CreateRoomJob::StateEvent>>>(_a[9])));
            if (_a[0]) *reinterpret_cast<JobHandle<CreateRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 73: { JobHandle<CreateRoomJob> _r = _t->createRoom((*reinterpret_cast<std::add_pointer_t<enum RoomVisibility>>(_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])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[8])));
            if (_a[0]) *reinterpret_cast<JobHandle<CreateRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 74: { JobHandle<CreateRoomJob> _r = _t->createRoom((*reinterpret_cast<std::add_pointer_t<enum RoomVisibility>>(_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])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])));
            if (_a[0]) *reinterpret_cast<JobHandle<CreateRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 75: { JobHandle<CreateRoomJob> _r = _t->createRoom((*reinterpret_cast<std::add_pointer_t<enum RoomVisibility>>(_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])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])));
            if (_a[0]) *reinterpret_cast<JobHandle<CreateRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 76: { JobHandle<CreateRoomJob> _r = _t->createRoom((*reinterpret_cast<std::add_pointer_t<enum RoomVisibility>>(_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])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[5])));
            if (_a[0]) *reinterpret_cast<JobHandle<CreateRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 77: { JobHandle<CreateRoomJob> _r = _t->createRoom((*reinterpret_cast<std::add_pointer_t<enum RoomVisibility>>(_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])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[8])),(*reinterpret_cast<std::add_pointer_t<QList<CreateRoomJob::StateEvent>>>(_a[9])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[10])),(*reinterpret_cast<std::add_pointer_t<QList<Invite3pid>>>(_a[11])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[12])));
            if (_a[0]) *reinterpret_cast<JobHandle<CreateRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 78: { JobHandle<CreateRoomJob> _r = _t->createRoom((*reinterpret_cast<std::add_pointer_t<enum RoomVisibility>>(_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])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[8])),(*reinterpret_cast<std::add_pointer_t<QList<CreateRoomJob::StateEvent>>>(_a[9])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[10])),(*reinterpret_cast<std::add_pointer_t<QList<Invite3pid>>>(_a[11])));
            if (_a[0]) *reinterpret_cast<JobHandle<CreateRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 79: { JobHandle<CreateRoomJob> _r = _t->createRoom((*reinterpret_cast<std::add_pointer_t<enum RoomVisibility>>(_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])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[8])),(*reinterpret_cast<std::add_pointer_t<QList<CreateRoomJob::StateEvent>>>(_a[9])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[10])));
            if (_a[0]) *reinterpret_cast<JobHandle<CreateRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 80: _t->requestDirectChat((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 81: { ForgetRoomJob* _r = _t->forgetRoom((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<ForgetRoomJob**>(_a[0]) = std::move(_r); }  break;
        case 82: { SendToDeviceJob* _r = _t->sendToDevices((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<UsersToDevicesToContent>>(_a[2])));
            if (_a[0]) *reinterpret_cast<SendToDeviceJob**>(_a[0]) = std::move(_r); }  break;
        case 83: { SendMessageJob* _r = _t->sendMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<RoomEvent>>(_a[2])));
            if (_a[0]) *reinterpret_cast<SendMessageJob**>(_a[0]) = std::move(_r); }  break;
        case 84: { LeaveRoomJob* _r = _t->leaveRoom((*reinterpret_cast<std::add_pointer_t<Room*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<LeaveRoomJob**>(_a[0]) = std::move(_r); }  break;
        case 85: { Quotient::KeyVerificationSession* _r = _t->startKeyVerificationSession((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<Quotient::KeyVerificationSession**>(_a[0]) = std::move(_r); }  break;
        case 86: _t->startSelfVerification(); break;
        case 87: _t->encryptionUpdate((*reinterpret_cast<std::add_pointer_t<const Room*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2]))); break;
        case 88: _t->encryptionUpdate((*reinterpret_cast<std::add_pointer_t<const Room*>>(_a[1]))); break;
        case 89: { Connection* _r = _t->makeMockConnection((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<Connection**>(_a[0]) = std::move(_r); }  break;
        case 90: { Connection* _r = _t->makeMockConnection((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<Connection**>(_a[0]) = std::move(_r); }  break;
        case 91: _t->syncLoopIteration(); break;
        case 92: { QList<Quotient::Room*> _r = _t->allRooms();
            if (_a[0]) *reinterpret_cast<QList<Quotient::Room*>*>(_a[0]) = std::move(_r); }  break;
        case 93: { QList<Quotient::Room*> _r = _t->rooms((*reinterpret_cast<std::add_pointer_t<Quotient::JoinStates>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<Quotient::Room*>*>(_a[0]) = std::move(_r); }  break;
        case 94: { int _r = _t->roomsCount((*reinterpret_cast<std::add_pointer_t<Quotient::JoinStates>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 95: { QJsonObject _r = _t->accountDataJson((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QJsonObject*>(_a[0]) = std::move(_r); }  break;
        case 96: _t->setAccountData((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[2]))); break;
        case 97: { bool _r = _t->isIgnored((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 98: { bool _r = _t->isIgnored((*reinterpret_cast<std::add_pointer_t<const Quotient::User*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 99: { Quotient::IgnoredUsersList _r = _t->ignoredUsers();
            if (_a[0]) *reinterpret_cast<Quotient::IgnoredUsersList*>(_a[0]) = std::move(_r); }  break;
        case 100: _t->addToIgnoredUsers((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 101: _t->removeFromIgnoredUsers((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 102: { QStringList _r = _t->userIds();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 103: { std::optional<LoginFlow> _r = _t->getLoginFlow((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<std::optional<LoginFlow>*>(_a[0]) = std::move(_r); }  break;
        case 104: { Quotient::Room* _r = _t->room((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Quotient::JoinStates>>(_a[2])));
            if (_a[0]) *reinterpret_cast<Quotient::Room**>(_a[0]) = std::move(_r); }  break;
        case 105: { Quotient::Room* _r = _t->room((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<Quotient::Room**>(_a[0]) = std::move(_r); }  break;
        case 106: { Quotient::Room* _r = _t->roomByAlias((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Quotient::JoinStates>>(_a[2])));
            if (_a[0]) *reinterpret_cast<Quotient::Room**>(_a[0]) = std::move(_r); }  break;
        case 107: { Quotient::Room* _r = _t->roomByAlias((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<Quotient::Room**>(_a[0]) = std::move(_r); }  break;
        case 108: { Quotient::Room* _r = _t->invitation((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<Quotient::Room**>(_a[0]) = std::move(_r); }  break;
        case 109: { Quotient::User* _r = _t->user((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<Quotient::User**>(_a[0]) = std::move(_r); }  break;
        case 110: { bool _r = _t->isQueryingKeys();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 111: { bool _r = _t->isUserVerified((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 112: { bool _r = _t->allSessionsSelfVerified((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 113: { Quotient::SyncJob* _r = _t->syncJob();
            if (_a[0]) *reinterpret_cast<Quotient::SyncJob**>(_a[0]) = std::move(_r); }  break;
        case 114: { QString _r = _t->nextBatchToken();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 115: { int _r = _t->millisToReconnect();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 116: _t->getTurnServers(); break;
        case 117: { bool _r = _t->capabilitiesReady();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 118: { bool _r = _t->loadingCapabilities();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 119: _t->loadState(); break;
        case 120: _t->saveState(); break;
        case 121: { QString _r = _t->stateCachePath();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 122: { BaseJob* _r = _t->run((*reinterpret_cast<std::add_pointer_t<BaseJob*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<RunningPolicy>>(_a[2])));
            if (_a[0]) *reinterpret_cast<BaseJob**>(_a[0]) = std::move(_r); }  break;
        case 123: { BaseJob* _r = _t->run((*reinterpret_cast<std::add_pointer_t<BaseJob*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<BaseJob**>(_a[0]) = std::move(_r); }  break;
        case 124: { SsoSession* _r = _t->prepareForSso((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<SsoSession**>(_a[0]) = std::move(_r); }  break;
        case 125: { SsoSession* _r = _t->prepareForSso((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<SsoSession**>(_a[0]) = std::move(_r); }  break;
        case 126: { QString _r = _t->generateTxnId();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 127: { QUrl _r = _t->makeMediaUrl((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QUrl*>(_a[0]) = std::move(_r); }  break;
        case 128: { bool _r = _t->roomSucceeds((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 129: _t->resolveServer((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 130: { QFuture<QList<LoginFlow>> _r = _t->setHomeserver((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QFuture<QList<LoginFlow>>*>(_a[0]) = std::move(_r); }  break;
        case 131: { QFuture<Room*> _r = _t->getDirectChat((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QFuture<Room*>*>(_a[0]) = std::move(_r); }  break;
        case 132: { JobHandle<CreateRoomJob> _r = _t->createDirectChat((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<JobHandle<CreateRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 133: { JobHandle<CreateRoomJob> _r = _t->createDirectChat((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<JobHandle<CreateRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 134: { JobHandle<CreateRoomJob> _r = _t->createDirectChat((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<JobHandle<CreateRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 135: { JobHandle<JoinRoomJob> _r = _t->joinRoom((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])));
            if (_a[0]) *reinterpret_cast<JobHandle<JoinRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 136: { JobHandle<JoinRoomJob> _r = _t->joinRoom((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<JobHandle<JoinRoomJob>*>(_a[0]) = std::move(_r); }  break;
        case 137: { QFuture<Room*> _r = _t->joinAndGetRoom((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QFuture<Room*>*>(_a[0]) = std::move(_r); }  break;
        case 138: { QFuture<Room*> _r = _t->joinAndGetRoom((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QFuture<Room*>*>(_a[0]) = std::move(_r); }  break;
        case 139: { QFuture<Room*> _r = _t->waitForNewRoom((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QFuture<Room*>*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 9:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Quotient::BaseJob* >(); break;
            }
            break;
        case 23:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Quotient::DirectChatsMap >(); break;
            }
            break;
        case 24:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Quotient::IgnoredUsersList >(); 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< Quotient::KeyVerificationSession* >(); break;
            }
            break;
        case 59:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QIODevice* >(); break;
            }
            break;
        case 60:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QIODevice* >(); 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< QIODevice* >(); break;
            }
            break;
        case 122:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< BaseJob* >(); break;
            }
            break;
        case 123:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< BaseJob* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(QString )>(_a, &Connection::resolveError, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(QUrl )>(_a, &Connection::homeserverChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::loginFlowsChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::capabilitiesLoaded, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::connected, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::loggedOut, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::stateChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::isOnlineChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(QString , QString )>(_a, &Connection::loginError, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(Quotient::BaseJob * )>(_a, &Connection::requestFailed, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(QString , QString , int , int )>(_a, &Connection::networkError, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::syncDone, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(QString , QString )>(_a, &Connection::syncError, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(Quotient::User * )>(_a, &Connection::newUser, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(Quotient::Room * )>(_a, &Connection::newRoom, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(Quotient::Room * , Quotient::Room * )>(_a, &Connection::invitedRoom, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(Quotient::Room * , Quotient::Room * )>(_a, &Connection::joinedRoom, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(Quotient::Room * , Quotient::Room * )>(_a, &Connection::leftRoom, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(Quotient::Room * )>(_a, &Connection::aboutToDeleteRoom, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(Quotient::Room * )>(_a, &Connection::createdRoom, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(Quotient::Room * )>(_a, &Connection::loadedRoomState, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(QString )>(_a, &Connection::accountDataChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(Quotient::Room * )>(_a, &Connection::directChatAvailable, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(Quotient::DirectChatsMap , Quotient::DirectChatsMap )>(_a, &Connection::directChatsListChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(Quotient::IgnoredUsersList , Quotient::IgnoredUsersList )>(_a, &Connection::ignoredUsersListChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::cacheStateChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::lazyLoadingChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(const QJsonObject & )>(_a, &Connection::turnServersChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::devicesListLoaded, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(bool )>(_a, &Connection::encryptionChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(bool )>(_a, &Connection::directChatsEncryptionChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(Quotient::KeyVerificationSession * )>(_a, &Connection::newKeyVerificationSession, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(const Quotient::KeyVerificationSession * , Quotient::KeyVerificationSession::State )>(_a, &Connection::keyVerificationStateChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(const QString & , const QString & )>(_a, &Connection::sessionVerified, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::finishedQueryingKeys, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(const QString & , const QString & )>(_a, &Connection::secretReceived, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)(const QString & )>(_a, &Connection::userVerified, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::crossSigningSetupRequired, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::ready, 38))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<User**>(_v) = _t->user(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->userId(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->domain(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->deviceId(); break;
        case 4: *reinterpret_cast<QByteArray*>(_v) = _t->accessToken(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->isLoggedIn(); break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->isOnline(); break;
        case 7: *reinterpret_cast<QString*>(_v) = _t->defaultRoomVersion(); break;
        case 8: *reinterpret_cast<QUrl*>(_v) = _t->homeserver(); break;
        case 9: *reinterpret_cast<QList<GetLoginFlowsJob::LoginFlow>*>(_v) = _t->loginFlows(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->isUsable(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->supportsSso(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->supportsPasswordAuth(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->cacheState(); break;
        case 14: *reinterpret_cast<bool*>(_v) = _t->lazyLoading(); break;
        case 15: *reinterpret_cast<bool*>(_v) = _t->canChangePassword(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->encryptionEnabled(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->directChatEncryptionEnabled(); break;
        case 18: *reinterpret_cast<QStringList*>(_v) = _t->accountDataEventTypes(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 8: _t->setHomeserver(*reinterpret_cast<QUrl*>(_v)); break;
        case 13: _t->setCacheState(*reinterpret_cast<bool*>(_v)); break;
        case 14: _t->setLazyLoading(*reinterpret_cast<bool*>(_v)); break;
        case 16: _t->enableEncryption(*reinterpret_cast<bool*>(_v)); break;
        case 17: _t->enableDirectChatEncryption(*reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}

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

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

int Quotient::Connection::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 < 140)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 140;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 140)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 140;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 19;
    }
    return _id;
}

// SIGNAL 0
void Quotient::Connection::resolveError(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void Quotient::Connection::homeserverChanged(QUrl _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void Quotient::Connection::loginFlowsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void Quotient::Connection::capabilitiesLoaded()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void Quotient::Connection::connected()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void Quotient::Connection::loggedOut()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void Quotient::Connection::stateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void Quotient::Connection::isOnlineChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void Quotient::Connection::loginError(QString _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1, _t2);
}

// SIGNAL 9
void Quotient::Connection::requestFailed(Quotient::BaseJob * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void Quotient::Connection::networkError(QString _t1, QString _t2, int _t3, int _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 11
void Quotient::Connection::syncDone()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void Quotient::Connection::syncError(QString _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1, _t2);
}

// SIGNAL 13
void Quotient::Connection::newUser(Quotient::User * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void Quotient::Connection::newRoom(Quotient::Room * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void Quotient::Connection::invitedRoom(Quotient::Room * _t1, Quotient::Room * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1, _t2);
}

// SIGNAL 16
void Quotient::Connection::joinedRoom(Quotient::Room * _t1, Quotient::Room * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1, _t2);
}

// SIGNAL 17
void Quotient::Connection::leftRoom(Quotient::Room * _t1, Quotient::Room * _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1, _t2);
}

// SIGNAL 18
void Quotient::Connection::aboutToDeleteRoom(Quotient::Room * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void Quotient::Connection::createdRoom(Quotient::Room * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void Quotient::Connection::loadedRoomState(Quotient::Room * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void Quotient::Connection::accountDataChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void Quotient::Connection::directChatAvailable(Quotient::Room * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void Quotient::Connection::directChatsListChanged(Quotient::DirectChatsMap _t1, Quotient::DirectChatsMap _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1, _t2);
}

// SIGNAL 24
void Quotient::Connection::ignoredUsersListChanged(Quotient::IgnoredUsersList _t1, Quotient::IgnoredUsersList _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1, _t2);
}

// SIGNAL 25
void Quotient::Connection::cacheStateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 25, nullptr);
}

// SIGNAL 26
void Quotient::Connection::lazyLoadingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 26, nullptr);
}

// SIGNAL 27
void Quotient::Connection::turnServersChanged(const QJsonObject & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1);
}

// SIGNAL 28
void Quotient::Connection::devicesListLoaded()
{
    QMetaObject::activate(this, &staticMetaObject, 28, nullptr);
}

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

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

// SIGNAL 31
void Quotient::Connection::newKeyVerificationSession(Quotient::KeyVerificationSession * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1);
}

// SIGNAL 32
void Quotient::Connection::keyVerificationStateChanged(const Quotient::KeyVerificationSession * _t1, Quotient::KeyVerificationSession::State _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 32, nullptr, _t1, _t2);
}

// SIGNAL 33
void Quotient::Connection::sessionVerified(const QString & _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 33, nullptr, _t1, _t2);
}

// SIGNAL 34
void Quotient::Connection::finishedQueryingKeys()
{
    QMetaObject::activate(this, &staticMetaObject, 34, nullptr);
}

// SIGNAL 35
void Quotient::Connection::secretReceived(const QString & _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 35, nullptr, _t1, _t2);
}

// SIGNAL 36
void Quotient::Connection::userVerified(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 36, nullptr, _t1);
}

// SIGNAL 37
void Quotient::Connection::crossSigningSetupRequired()
{
    QMetaObject::activate(this, &staticMetaObject, 37, nullptr);
}

// SIGNAL 38
void Quotient::Connection::ready()
{
    QMetaObject::activate(this, &staticMetaObject, 38, nullptr);
}
QT_WARNING_POP
