/****************************************************************************
** Meta object code from reading C++ file 'syncthingconnection.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 "../../syncthingconnection.h"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'syncthingconnection.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_ZN4Data19SyncthingConnectionE_t {};
} // unnamed namespace

template <> constexpr inline auto Data::SyncthingConnection::qt_create_metaobjectdata<qt_meta_tag_ZN4Data19SyncthingConnectionE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Data::SyncthingConnection",
        "syncthingUrlChanged",
        "",
        "newUrl",
        "autoReconnectIntervalChanged",
        "autoReconnectInterval",
        "newConfig",
        "QJsonObject",
        "rawConfig",
        "newDirs",
        "std::vector<Data::SyncthingDir>",
        "dirs",
        "newDevices",
        "std::vector<Data::SyncthingDev>",
        "devs",
        "newErrors",
        "std::vector<Data::SyncthingError>",
        "errors",
        "beforeNewErrors",
        "oldErrors",
        "newConfigApplied",
        "newEvents",
        "QJsonArray",
        "events",
        "allEventsProcessed",
        "dirStatusChanged",
        "Data::SyncthingDir",
        "dir",
        "index",
        "devStatusChanged",
        "Data::SyncthingDev",
        "dev",
        "fileChanged",
        "Data::SyncthingFileChange",
        "fileChange",
        "downloadProgressChanged",
        "dirStatisticsChanged",
        "devCompletionChanged",
        "dirCompleted",
        "CppUtilities::DateTime",
        "when",
        "const Data::SyncthingDev*",
        "remoteDev",
        "newNotification",
        "message",
        "newDevAvailable",
        "devId",
        "address",
        "newDirAvailable",
        "dirId",
        "dirLabel",
        "error",
        "errorMessage",
        "Data::SyncthingErrorCategory",
        "category",
        "networkError",
        "QNetworkRequest",
        "request",
        "response",
        "statusChanged",
        "Data::SyncthingStatus",
        "newStatus",
        "configDirChanged",
        "newConfigDir",
        "myIdChanged",
        "myNewId",
        "tildeChanged",
        "tilde",
        "trafficChanged",
        "std::uint64_t",
        "totalIncomingTraffic",
        "totalOutgoingTraffic",
        "newConfigTriggered",
        "rescanTriggered",
        "devicePauseTriggered",
        "devIds",
        "deviceResumeTriggered",
        "directoryPauseTriggered",
        "dirIds",
        "directoryResumeTriggered",
        "suspensionOrResumeTriggered",
        "suspended",
        "restartTriggered",
        "shutdownTriggered",
        "errorsCleared",
        "logAvailable",
        "std::vector<Data::SyncthingLogEntry>",
        "logEntries",
        "qrCodeAvailable",
        "text",
        "qrCodeData",
        "overrideTriggered",
        "revertTriggered",
        "hasOutOfSyncDirsChanged",
        "hasStateChanged",
        "loadSelfSignedCertificate",
        "QUrl",
        "url",
        "clearSelfSignedCertificate",
        "applySettings",
        "Data::SyncthingConnectionSettings&",
        "connectionSettings",
        "applyRawConfig",
        "postRawConfig",
        "connect",
        "connectLater",
        "milliSeconds",
        "disconnect",
        "reconnect",
        "reconnectLater",
        "abortAllRequests",
        "clearConnectionCache",
        "pauseDevice",
        "pauseAllDevs",
        "resumeDevice",
        "resumeAllDevs",
        "pauseDirectories",
        "pauseAllDirs",
        "resumeDirectories",
        "resumeAllDirs",
        "rescan",
        "relpath",
        "rescanAllDirs",
        "restart",
        "shutdown",
        "suspendOrResume",
        "suspend",
        "changeStatus",
        "requestConfig",
        "requestStatus",
        "requestConfigAndStatus",
        "requestEvents",
        "requestErrors",
        "requestConnections",
        "requestClearingErrors",
        "requestDirStatistics",
        "requestDirStatus",
        "requestDirPullErrors",
        "page",
        "perPage",
        "requestCompletion",
        "requestDeviceStatistics",
        "requestVersion",
        "requestDiskEvents",
        "limit",
        "requestQrCode",
        "requestLog",
        "requestOverride",
        "requestRevert",
        "readConfig",
        "readDirs",
        "readDevs",
        "readStatus",
        "concludeReadingConfigAndStatus",
        "readConnections",
        "readDirStatistics",
        "readDeviceStatistics",
        "readErrors",
        "readClearingErrors",
        "readEvents",
        "readEventsFromJsonArray",
        "quint64&",
        "idVariable",
        "readStartingEvent",
        "eventData",
        "readStatusChangedEvent",
        "SyncthingEventId",
        "eventId",
        "eventTime",
        "readDownloadProgressEvent",
        "readDirEvent",
        "eventType",
        "readDeviceEvent",
        "readItemFinished",
        "readFolderErrors",
        "Data::SyncthingDir&",
        "dirInfo",
        "readFolderCompletion",
        "Data::SyncthingDir*",
        "dirIndex",
        "Data::SyncthingDev*",
        "devInfo",
        "devIndex",
        "readLocalFolderCompletion",
        "readRemoteFolderCompletion",
        "Data::SyncthingCompletion",
        "completion",
        "readRemoteIndexUpdated",
        "readRescan",
        "readDevPauseResume",
        "readDirPauseResume",
        "readRestart",
        "readShutdown",
        "readSuspend",
        "readDirStatus",
        "readDirPullErrors",
        "readDirSummary",
        "summary",
        "readDirRejected",
        "readDevRejected",
        "readCompletion",
        "readVersion",
        "readDiskEvents",
        "readChangeEvent",
        "readLog",
        "readQrCode",
        "readOverride",
        "readRevert",
        "continueConnecting",
        "continueReconnecting",
        "autoReconnect",
        "setStatus",
        "status",
        "emitError",
        "QJsonParseError",
        "jsonError",
        "QNetworkReply*",
        "reply",
        "emitMyIdChanged",
        "newId",
        "emitTildeChanged",
        "newTilde",
        "newPathSeparator",
        "handleFatalConnectionError",
        "handleAdditionalRequestCanceled",
        "handleSslErrors",
        "QList<QSslError>",
        "handleRedirection",
        "handleMeteredConnection",
        "recalculateStatus",
        "invalidateHasOutOfSyncDirs",
        "makeUrlWithCredentials",
        "substituteTilde",
        "path",
        "deviceNameOrId",
        "deviceId",
        "fullPath",
        "relativePath",
        "syncthingUrl",
        "syncthingUrlWithCredentials",
        "localPath",
        "apiKey",
        "local",
        "user",
        "password",
        "statusComputionFlags",
        "Data::SyncthingStatusComputionFlags",
        "loggingFlags",
        "Data::SyncthingConnectionLoggingFlags",
        "statusText",
        "connected",
        "connecting",
        "aborted",
        "hasErrors",
        "hasOutOfSyncDirs",
        "hasState",
        "requestingCompletionEnabled",
        "autoReconnectTries",
        "trafficPollInterval",
        "devStatsPollInterval",
        "recordFileChanges",
        "requestTimeout",
        "longPollingTimeout",
        "diskEventLimit",
        "myId",
        "pathSeparator",
        "configDir",
        "totalIncomingRate",
        "totalOutgoingRate",
        "overallDirStatistics",
        "Data::SyncthingOverallDirStatistics",
        "overallRemoteCompletion",
        "lastSyncedFile",
        "syncthingVersion",
        "lastSyncTime",
        "expectedSslErrors",
        "connectedDevices",
        "std::vector<const SyncthingDev*>",
        "directoryIds",
        "deviceIds",
        "guiRequiringAuth",
        "useDeprecatedRoutes",
        "pausingOnMeteredConnection",
        "forceSuspendEnabled",
        "insecure"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'syncthingUrlChanged'
        QtMocHelpers::SignalData<void(const QString &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'autoReconnectIntervalChanged'
        QtMocHelpers::SignalData<void(int)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Signal 'newConfig'
        QtMocHelpers::SignalData<void(const QJsonObject &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 7, 8 },
        }}),
        // Signal 'newDirs'
        QtMocHelpers::SignalData<void(const std::vector<Data::SyncthingDir> &)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 11 },
        }}),
        // Signal 'newDevices'
        QtMocHelpers::SignalData<void(const std::vector<Data::SyncthingDev> &)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 13, 14 },
        }}),
        // Signal 'newErrors'
        QtMocHelpers::SignalData<void(const std::vector<Data::SyncthingError> &)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 16, 17 },
        }}),
        // Signal 'beforeNewErrors'
        QtMocHelpers::SignalData<void(const std::vector<Data::SyncthingError> &, const std::vector<Data::SyncthingError> &)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 16, 19 }, { 0x80000000 | 16, 15 },
        }}),
        // Signal 'newConfigApplied'
        QtMocHelpers::SignalData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'newEvents'
        QtMocHelpers::SignalData<void(const QJsonArray &)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 23 },
        }}),
        // Signal 'allEventsProcessed'
        QtMocHelpers::SignalData<void()>(24, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'dirStatusChanged'
        QtMocHelpers::SignalData<void(const Data::SyncthingDir &, int)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 26, 27 }, { QMetaType::Int, 28 },
        }}),
        // Signal 'devStatusChanged'
        QtMocHelpers::SignalData<void(const Data::SyncthingDev &, int)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 30, 31 }, { QMetaType::Int, 28 },
        }}),
        // Signal 'fileChanged'
        QtMocHelpers::SignalData<void(const Data::SyncthingDir &, int, const Data::SyncthingFileChange &)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 26, 27 }, { QMetaType::Int, 28 }, { 0x80000000 | 33, 34 },
        }}),
        // Signal 'downloadProgressChanged'
        QtMocHelpers::SignalData<void()>(35, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'dirStatisticsChanged'
        QtMocHelpers::SignalData<void()>(36, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'devCompletionChanged'
        QtMocHelpers::SignalData<void()>(37, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'dirCompleted'
        QtMocHelpers::SignalData<void(CppUtilities::DateTime, const Data::SyncthingDir &, int, const Data::SyncthingDev *)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 39, 40 }, { 0x80000000 | 26, 27 }, { QMetaType::Int, 28 }, { 0x80000000 | 41, 42 },
        }}),
        // Signal 'dirCompleted'
        QtMocHelpers::SignalData<void(CppUtilities::DateTime, const Data::SyncthingDir &, int)>(38, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 39, 40 }, { 0x80000000 | 26, 27 }, { QMetaType::Int, 28 },
        }}),
        // Signal 'newNotification'
        QtMocHelpers::SignalData<void(CppUtilities::DateTime, const QString &)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 39, 40 }, { QMetaType::QString, 44 },
        }}),
        // Signal 'newDevAvailable'
        QtMocHelpers::SignalData<void(CppUtilities::DateTime, const QString &, const QString &)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 39, 40 }, { QMetaType::QString, 46 }, { QMetaType::QString, 47 },
        }}),
        // Signal 'newDirAvailable'
        QtMocHelpers::SignalData<void(CppUtilities::DateTime, const QString &, const Data::SyncthingDev *, const QString &, const QString &)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 39, 40 }, { QMetaType::QString, 46 }, { 0x80000000 | 41, 31 }, { QMetaType::QString, 49 },
            { QMetaType::QString, 50 },
        }}),
        // Signal 'error'
        QtMocHelpers::SignalData<void(const QString &, Data::SyncthingErrorCategory, int, const QNetworkRequest &, const QByteArray &)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 52 }, { 0x80000000 | 53, 54 }, { QMetaType::Int, 55 }, { 0x80000000 | 56, 57 },
            { QMetaType::QByteArray, 58 },
        }}),
        // Signal 'error'
        QtMocHelpers::SignalData<void(const QString &, Data::SyncthingErrorCategory, int, const QNetworkRequest &)>(51, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 52 }, { 0x80000000 | 53, 54 }, { QMetaType::Int, 55 }, { 0x80000000 | 56, 57 },
        }}),
        // Signal 'error'
        QtMocHelpers::SignalData<void(const QString &, Data::SyncthingErrorCategory, int)>(51, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 52 }, { 0x80000000 | 53, 54 }, { QMetaType::Int, 55 },
        }}),
        // Signal 'statusChanged'
        QtMocHelpers::SignalData<void(Data::SyncthingStatus)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 60, 61 },
        }}),
        // Signal 'configDirChanged'
        QtMocHelpers::SignalData<void(const QString &)>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 63 },
        }}),
        // Signal 'myIdChanged'
        QtMocHelpers::SignalData<void(const QString &)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 65 },
        }}),
        // Signal 'tildeChanged'
        QtMocHelpers::SignalData<void(const QString &)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 67 },
        }}),
        // Signal 'trafficChanged'
        QtMocHelpers::SignalData<void(std::uint64_t, std::uint64_t)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 69, 70 }, { 0x80000000 | 69, 71 },
        }}),
        // Signal 'newConfigTriggered'
        QtMocHelpers::SignalData<void()>(72, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'rescanTriggered'
        QtMocHelpers::SignalData<void(const QString &)>(73, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 49 },
        }}),
        // Signal 'devicePauseTriggered'
        QtMocHelpers::SignalData<void(const QStringList &)>(74, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 75 },
        }}),
        // Signal 'deviceResumeTriggered'
        QtMocHelpers::SignalData<void(const QStringList &)>(76, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 75 },
        }}),
        // Signal 'directoryPauseTriggered'
        QtMocHelpers::SignalData<void(const QStringList &)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 78 },
        }}),
        // Signal 'directoryResumeTriggered'
        QtMocHelpers::SignalData<void(const QStringList &)>(79, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 78 },
        }}),
        // Signal 'suspensionOrResumeTriggered'
        QtMocHelpers::SignalData<void(bool)>(80, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 81 },
        }}),
        // Signal 'restartTriggered'
        QtMocHelpers::SignalData<void()>(82, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'shutdownTriggered'
        QtMocHelpers::SignalData<void()>(83, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'errorsCleared'
        QtMocHelpers::SignalData<void()>(84, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'logAvailable'
        QtMocHelpers::SignalData<void(const std::vector<Data::SyncthingLogEntry> &)>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 86, 87 },
        }}),
        // Signal 'qrCodeAvailable'
        QtMocHelpers::SignalData<void(const QString &, const QByteArray &)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 89 }, { QMetaType::QByteArray, 90 },
        }}),
        // Signal 'overrideTriggered'
        QtMocHelpers::SignalData<void(const QString &)>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 49 },
        }}),
        // Signal 'revertTriggered'
        QtMocHelpers::SignalData<void(const QString &)>(92, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 49 },
        }}),
        // Signal 'hasOutOfSyncDirsChanged'
        QtMocHelpers::SignalData<void()>(93, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'hasStateChanged'
        QtMocHelpers::SignalData<void()>(94, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'loadSelfSignedCertificate'
        QtMocHelpers::SlotData<bool(const QUrl &)>(95, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 96, 97 },
        }}),
        // Slot 'loadSelfSignedCertificate'
        QtMocHelpers::SlotData<bool()>(95, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool),
        // Slot 'clearSelfSignedCertificate'
        QtMocHelpers::SlotData<void()>(98, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'applySettings'
        QtMocHelpers::SlotData<bool(Data::SyncthingConnectionSettings &)>(99, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 100, 101 },
        }}),
        // Slot 'applyRawConfig'
        QtMocHelpers::SlotData<void()>(102, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'postRawConfig'
        QtMocHelpers::SlotData<void(const QByteArray &)>(103, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 8 },
        }}),
        // Slot 'connect'
        QtMocHelpers::SlotData<void()>(104, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'connect'
        QtMocHelpers::SlotData<void(Data::SyncthingConnectionSettings &)>(104, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 100, 101 },
        }}),
        // Slot 'connectLater'
        QtMocHelpers::SlotData<void(int)>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 106 },
        }}),
        // Slot 'disconnect'
        QtMocHelpers::SlotData<void()>(107, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'reconnect'
        QtMocHelpers::SlotData<void()>(108, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'reconnect'
        QtMocHelpers::SlotData<void(Data::SyncthingConnectionSettings &)>(108, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 100, 101 },
        }}),
        // Slot 'reconnectLater'
        QtMocHelpers::SlotData<void(int)>(109, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 106 },
        }}),
        // Slot 'abortAllRequests'
        QtMocHelpers::SlotData<void()>(110, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'clearConnectionCache'
        QtMocHelpers::SlotData<void()>(111, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'pauseDevice'
        QtMocHelpers::SlotData<bool(const QStringList &)>(112, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QStringList, 75 },
        }}),
        // Slot 'pauseAllDevs'
        QtMocHelpers::SlotData<bool()>(113, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'resumeDevice'
        QtMocHelpers::SlotData<bool(const QStringList &)>(114, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QStringList, 75 },
        }}),
        // Slot 'resumeAllDevs'
        QtMocHelpers::SlotData<bool()>(115, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'pauseDirectories'
        QtMocHelpers::SlotData<bool(const QStringList &)>(116, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QStringList, 78 },
        }}),
        // Slot 'pauseAllDirs'
        QtMocHelpers::SlotData<bool()>(117, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'resumeDirectories'
        QtMocHelpers::SlotData<bool(const QStringList &)>(118, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QStringList, 78 },
        }}),
        // Slot 'resumeAllDirs'
        QtMocHelpers::SlotData<bool()>(119, 2, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'rescan'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(120, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 49 }, { QMetaType::QString, 121 },
        }}),
        // Slot 'rescan'
        QtMocHelpers::SlotData<void(const QString &)>(120, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 49 },
        }}),
        // Slot 'rescanAllDirs'
        QtMocHelpers::SlotData<void()>(122, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'restart'
        QtMocHelpers::SlotData<void()>(123, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'shutdown'
        QtMocHelpers::SlotData<void()>(124, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'suspendOrResume'
        QtMocHelpers::SlotData<bool(bool)>(125, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::Bool, 126 },
        }}),
        // Slot 'suspendOrResume'
        QtMocHelpers::SlotData<bool()>(125, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool),
        // Slot 'changeStatus'
        QtMocHelpers::SlotData<void()>(127, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestConfig'
        QtMocHelpers::SlotData<void()>(128, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestStatus'
        QtMocHelpers::SlotData<void()>(129, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestConfigAndStatus'
        QtMocHelpers::SlotData<void()>(130, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestEvents'
        QtMocHelpers::SlotData<void()>(131, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestErrors'
        QtMocHelpers::SlotData<void()>(132, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestConnections'
        QtMocHelpers::SlotData<void()>(133, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestClearingErrors'
        QtMocHelpers::SlotData<void()>(134, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestDirStatistics'
        QtMocHelpers::SlotData<void()>(135, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestDirStatus'
        QtMocHelpers::SlotData<void(const QString &)>(136, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 49 },
        }}),
        // Slot 'requestDirPullErrors'
        QtMocHelpers::SlotData<void(const QString &, int, int)>(137, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 49 }, { QMetaType::Int, 138 }, { QMetaType::Int, 139 },
        }}),
        // Slot 'requestDirPullErrors'
        QtMocHelpers::SlotData<void(const QString &, int)>(137, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 49 }, { QMetaType::Int, 138 },
        }}),
        // Slot 'requestDirPullErrors'
        QtMocHelpers::SlotData<void(const QString &)>(137, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 49 },
        }}),
        // Slot 'requestCompletion'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(140, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 46 }, { QMetaType::QString, 49 },
        }}),
        // Slot 'requestDeviceStatistics'
        QtMocHelpers::SlotData<void()>(141, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestVersion'
        QtMocHelpers::SlotData<void()>(142, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestDiskEvents'
        QtMocHelpers::SlotData<void(int)>(143, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 144 },
        }}),
        // Slot 'requestDiskEvents'
        QtMocHelpers::SlotData<void()>(143, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'requestQrCode'
        QtMocHelpers::SlotData<void(const QString &)>(145, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 89 },
        }}),
        // Slot 'requestLog'
        QtMocHelpers::SlotData<void()>(146, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'requestOverride'
        QtMocHelpers::SlotData<void(const QString &)>(147, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 49 },
        }}),
        // Slot 'requestRevert'
        QtMocHelpers::SlotData<void(const QString &)>(148, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 49 },
        }}),
        // Slot 'readConfig'
        QtMocHelpers::SlotData<void()>(149, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readDirs'
        QtMocHelpers::SlotData<void(const QJsonArray &)>(150, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 22, 11 },
        }}),
        // Slot 'readDevs'
        QtMocHelpers::SlotData<void(const QJsonArray &)>(151, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 22, 14 },
        }}),
        // Slot 'readStatus'
        QtMocHelpers::SlotData<void()>(152, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'concludeReadingConfigAndStatus'
        QtMocHelpers::SlotData<void()>(153, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readConnections'
        QtMocHelpers::SlotData<void()>(154, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readDirStatistics'
        QtMocHelpers::SlotData<void()>(155, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readDeviceStatistics'
        QtMocHelpers::SlotData<void()>(156, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readErrors'
        QtMocHelpers::SlotData<void()>(157, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readClearingErrors'
        QtMocHelpers::SlotData<void()>(158, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readEvents'
        QtMocHelpers::SlotData<void()>(159, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readEventsFromJsonArray'
        QtMocHelpers::SlotData<bool(const QJsonArray &, quint64 &)>(160, 2, QMC::AccessPrivate, QMetaType::Bool, {{
            { 0x80000000 | 22, 23 }, { 0x80000000 | 161, 162 },
        }}),
        // Slot 'readStartingEvent'
        QtMocHelpers::SlotData<void(const QJsonObject &)>(163, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 7, 164 },
        }}),
        // Slot 'readStatusChangedEvent'
        QtMocHelpers::SlotData<void(SyncthingEventId, CppUtilities::DateTime, const QJsonObject &)>(165, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 166, 167 }, { 0x80000000 | 39, 168 }, { 0x80000000 | 7, 164 },
        }}),
        // Slot 'readDownloadProgressEvent'
        QtMocHelpers::SlotData<void(const QJsonObject &)>(169, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 7, 164 },
        }}),
        // Slot 'readDirEvent'
        QtMocHelpers::SlotData<void(SyncthingEventId, CppUtilities::DateTime, const QString &, const QJsonObject &)>(170, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 166, 167 }, { 0x80000000 | 39, 168 }, { QMetaType::QString, 171 }, { 0x80000000 | 7, 164 },
        }}),
        // Slot 'readDeviceEvent'
        QtMocHelpers::SlotData<void(SyncthingEventId, CppUtilities::DateTime, const QString &, const QJsonObject &)>(172, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 166, 167 }, { 0x80000000 | 39, 168 }, { QMetaType::QString, 171 }, { 0x80000000 | 7, 164 },
        }}),
        // Slot 'readItemFinished'
        QtMocHelpers::SlotData<void(SyncthingEventId, CppUtilities::DateTime, const QJsonObject &)>(173, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 166, 167 }, { 0x80000000 | 39, 168 }, { 0x80000000 | 7, 164 },
        }}),
        // Slot 'readFolderErrors'
        QtMocHelpers::SlotData<void(SyncthingEventId, CppUtilities::DateTime, const QJsonObject &, Data::SyncthingDir &, int)>(174, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 166, 167 }, { 0x80000000 | 39, 168 }, { 0x80000000 | 7, 164 }, { 0x80000000 | 175, 176 },
            { QMetaType::Int, 28 },
        }}),
        // Slot 'readFolderCompletion'
        QtMocHelpers::SlotData<void(SyncthingEventId, CppUtilities::DateTime, const QJsonObject &, const QString &, Data::SyncthingDir *, int)>(177, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 166, 167 }, { 0x80000000 | 39, 168 }, { 0x80000000 | 7, 164 }, { QMetaType::QString, 49 },
            { 0x80000000 | 178, 176 }, { QMetaType::Int, 179 },
        }}),
        // Slot 'readFolderCompletion'
        QtMocHelpers::SlotData<void(SyncthingEventId, CppUtilities::DateTime, const QJsonObject &, const QString &, Data::SyncthingDev *, int, const QString &, Data::SyncthingDir *, int)>(177, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 166, 167 }, { 0x80000000 | 39, 168 }, { 0x80000000 | 7, 164 }, { QMetaType::QString, 46 },
            { 0x80000000 | 180, 181 }, { QMetaType::Int, 182 }, { QMetaType::QString, 49 }, { 0x80000000 | 178, 176 },
            { QMetaType::Int, 179 },
        }}),
        // Slot 'readLocalFolderCompletion'
        QtMocHelpers::SlotData<void(SyncthingEventId, CppUtilities::DateTime, const QJsonObject &, Data::SyncthingDir &, int)>(183, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 166, 167 }, { 0x80000000 | 39, 168 }, { 0x80000000 | 7, 164 }, { 0x80000000 | 175, 176 },
            { QMetaType::Int, 28 },
        }}),
        // Slot 'readRemoteFolderCompletion'
        QtMocHelpers::SlotData<void(CppUtilities::DateTime, const QJsonObject &, const QString &, Data::SyncthingDev *, int, const QString &, Data::SyncthingDir *, int)>(184, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 39, 168 }, { 0x80000000 | 7, 164 }, { QMetaType::QString, 46 }, { 0x80000000 | 180, 181 },
            { QMetaType::Int, 182 }, { QMetaType::QString, 49 }, { 0x80000000 | 178, 176 }, { QMetaType::Int, 179 },
        }}),
        // Slot 'readRemoteFolderCompletion'
        QtMocHelpers::SlotData<void(const Data::SyncthingCompletion &, const QString &, Data::SyncthingDev *, int, const QString &, Data::SyncthingDir *, int)>(184, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 185, 186 }, { QMetaType::QString, 46 }, { 0x80000000 | 180, 181 }, { QMetaType::Int, 182 },
            { QMetaType::QString, 49 }, { 0x80000000 | 178, 176 }, { QMetaType::Int, 179 },
        }}),
        // Slot 'readRemoteIndexUpdated'
        QtMocHelpers::SlotData<void(SyncthingEventId, const QJsonObject &)>(187, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 166, 167 }, { 0x80000000 | 7, 164 },
        }}),
        // Slot 'readRescan'
        QtMocHelpers::SlotData<void()>(188, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readDevPauseResume'
        QtMocHelpers::SlotData<void()>(189, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readDirPauseResume'
        QtMocHelpers::SlotData<void()>(190, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readRestart'
        QtMocHelpers::SlotData<void()>(191, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readShutdown'
        QtMocHelpers::SlotData<void()>(192, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readSuspend'
        QtMocHelpers::SlotData<void()>(193, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readDirStatus'
        QtMocHelpers::SlotData<void()>(194, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readDirPullErrors'
        QtMocHelpers::SlotData<void()>(195, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readDirSummary'
        QtMocHelpers::SlotData<void(SyncthingEventId, CppUtilities::DateTime, const QJsonObject &, Data::SyncthingDir &, int)>(196, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 166, 167 }, { 0x80000000 | 39, 168 }, { 0x80000000 | 7, 197 }, { 0x80000000 | 175, 176 },
            { QMetaType::Int, 28 },
        }}),
        // Slot 'readDirRejected'
        QtMocHelpers::SlotData<void(CppUtilities::DateTime, const QString &, const QJsonObject &)>(198, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 39, 168 }, { QMetaType::QString, 49 }, { 0x80000000 | 7, 164 },
        }}),
        // Slot 'readDevRejected'
        QtMocHelpers::SlotData<void(CppUtilities::DateTime, const QString &, const QJsonObject &)>(199, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 39, 168 }, { QMetaType::QString, 46 }, { 0x80000000 | 7, 164 },
        }}),
        // Slot 'readCompletion'
        QtMocHelpers::SlotData<void()>(200, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readVersion'
        QtMocHelpers::SlotData<void()>(201, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readDiskEvents'
        QtMocHelpers::SlotData<void()>(202, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readChangeEvent'
        QtMocHelpers::SlotData<void(CppUtilities::DateTime, const QString &, const QJsonObject &)>(203, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 39, 168 }, { QMetaType::QString, 171 }, { 0x80000000 | 7, 164 },
        }}),
        // Slot 'readLog'
        QtMocHelpers::SlotData<void()>(204, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readQrCode'
        QtMocHelpers::SlotData<void()>(205, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readOverride'
        QtMocHelpers::SlotData<void()>(206, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'readRevert'
        QtMocHelpers::SlotData<void()>(207, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'continueConnecting'
        QtMocHelpers::SlotData<void()>(208, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'continueReconnecting'
        QtMocHelpers::SlotData<void()>(209, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'autoReconnect'
        QtMocHelpers::SlotData<void()>(210, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'setStatus'
        QtMocHelpers::SlotData<bool(Data::SyncthingStatus)>(211, 2, QMC::AccessPrivate, QMetaType::Bool, {{
            { 0x80000000 | 60, 212 },
        }}),
        // Slot 'emitError'
        QtMocHelpers::SlotData<void(const QString &, const QJsonParseError &, QNetworkReply *, const QByteArray &)>(213, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 44 }, { 0x80000000 | 214, 215 }, { 0x80000000 | 216, 217 }, { QMetaType::QByteArray, 58 },
        }}),
        // Slot 'emitError'
        QtMocHelpers::SlotData<void(const QString &, Data::SyncthingErrorCategory, QNetworkReply *, const QByteArray &)>(213, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 44 }, { 0x80000000 | 53, 54 }, { 0x80000000 | 216, 217 }, { QMetaType::QByteArray, 58 },
        }}),
        // Slot 'emitError'
        QtMocHelpers::SlotData<void(const QString &, QNetworkReply *, const QByteArray &)>(213, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 44 }, { 0x80000000 | 216, 217 }, { QMetaType::QByteArray, 58 },
        }}),
        // Slot 'emitMyIdChanged'
        QtMocHelpers::SlotData<void(const QString &)>(218, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 219 },
        }}),
        // Slot 'emitTildeChanged'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(220, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 221 }, { QMetaType::QString, 222 },
        }}),
        // Slot 'handleFatalConnectionError'
        QtMocHelpers::SlotData<void()>(223, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'handleAdditionalRequestCanceled'
        QtMocHelpers::SlotData<void()>(224, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'handleSslErrors'
        QtMocHelpers::SlotData<void(const QList<QSslError> &)>(225, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 226, 17 },
        }}),
        // Slot 'handleRedirection'
        QtMocHelpers::SlotData<void(const QUrl &)>(227, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 96, 97 },
        }}),
        // Slot 'handleMeteredConnection'
        QtMocHelpers::SlotData<bool()>(228, 2, QMC::AccessPrivate, QMetaType::Bool),
        // Slot 'recalculateStatus'
        QtMocHelpers::SlotData<void()>(229, 2, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'invalidateHasOutOfSyncDirs'
        QtMocHelpers::SlotData<void()>(230, 2, QMC::AccessPrivate, QMetaType::Void),
        // Method 'makeUrlWithCredentials'
        QtMocHelpers::MethodData<QUrl() const>(231, 2, QMC::AccessPublic, 0x80000000 | 96),
        // Method 'substituteTilde'
        QtMocHelpers::MethodData<QString(const QString &) const>(232, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 233 },
        }}),
        // Method 'deviceNameOrId'
        QtMocHelpers::MethodData<QString(const QString &) const>(234, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 235 },
        }}),
        // Method 'fullPath'
        QtMocHelpers::MethodData<QString(const QString &, const QString &) const>(236, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 49 }, { QMetaType::QString, 237 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'syncthingUrl'
        QtMocHelpers::PropertyData<QString>(238, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
        // property 'syncthingUrlWithCredentials'
        QtMocHelpers::PropertyData<QUrl>(239, 0x80000000 | 96, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
        // property 'localPath'
        QtMocHelpers::PropertyData<QString>(240, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'apiKey'
        QtMocHelpers::PropertyData<QByteArray>(241, QMetaType::QByteArray, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'local'
        QtMocHelpers::PropertyData<bool>(242, QMetaType::Bool, QMC::DefaultPropertyFlags, 0),
        // property 'user'
        QtMocHelpers::PropertyData<QString>(243, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'password'
        QtMocHelpers::PropertyData<QString>(244, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'status'
        QtMocHelpers::PropertyData<Data::SyncthingStatus>(212, 0x80000000 | 60, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 24),
        // property 'statusComputionFlags'
        QtMocHelpers::PropertyData<Data::SyncthingStatusComputionFlags>(245, 0x80000000 | 246, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'loggingFlags'
        QtMocHelpers::PropertyData<Data::SyncthingConnectionLoggingFlags>(247, 0x80000000 | 248, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet),
        // property 'statusText'
        QtMocHelpers::PropertyData<QString>(249, QMetaType::QString, QMC::DefaultPropertyFlags, 24),
        // property 'connected'
        QtMocHelpers::PropertyData<bool>(250, QMetaType::Bool, QMC::DefaultPropertyFlags, 24),
        // property 'connecting'
        QtMocHelpers::PropertyData<bool>(251, QMetaType::Bool, QMC::DefaultPropertyFlags, 24),
        // property 'aborted'
        QtMocHelpers::PropertyData<bool>(252, QMetaType::Bool, QMC::DefaultPropertyFlags, 24),
        // property 'hasErrors'
        QtMocHelpers::PropertyData<bool>(253, QMetaType::Bool, QMC::DefaultPropertyFlags, 5),
        // property 'hasOutOfSyncDirs'
        QtMocHelpers::PropertyData<bool>(254, QMetaType::Bool, QMC::DefaultPropertyFlags, 43),
        // property 'hasState'
        QtMocHelpers::PropertyData<bool>(255, QMetaType::Bool, QMC::DefaultPropertyFlags, 44),
        // property 'requestingCompletionEnabled'
        QtMocHelpers::PropertyData<bool>(256, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'autoReconnectInterval'
        QtMocHelpers::PropertyData<int>(5, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'autoReconnectTries'
        QtMocHelpers::PropertyData<uint>(257, QMetaType::UInt, QMC::DefaultPropertyFlags),
        // property 'trafficPollInterval'
        QtMocHelpers::PropertyData<int>(258, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'devStatsPollInterval'
        QtMocHelpers::PropertyData<int>(259, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'recordFileChanges'
        QtMocHelpers::PropertyData<bool>(260, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'requestTimeout'
        QtMocHelpers::PropertyData<int>(261, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'longPollingTimeout'
        QtMocHelpers::PropertyData<int>(262, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'diskEventLimit'
        QtMocHelpers::PropertyData<int>(263, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'myId'
        QtMocHelpers::PropertyData<QString>(264, QMetaType::QString, QMC::DefaultPropertyFlags, 26),
        // property 'tilde'
        QtMocHelpers::PropertyData<QString>(67, QMetaType::QString, QMC::DefaultPropertyFlags, 27),
        // property 'pathSeparator'
        QtMocHelpers::PropertyData<QString>(265, QMetaType::QString, QMC::DefaultPropertyFlags, 27),
        // property 'configDir'
        QtMocHelpers::PropertyData<QString>(266, QMetaType::QString, QMC::DefaultPropertyFlags, 25),
        // property 'totalIncomingTraffic'
        QtMocHelpers::PropertyData<quint64>(70, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 28),
        // property 'totalOutgoingTraffic'
        QtMocHelpers::PropertyData<quint64>(71, QMetaType::ULongLong, QMC::DefaultPropertyFlags, 28),
        // property 'totalIncomingRate'
        QtMocHelpers::PropertyData<double>(267, QMetaType::Double, QMC::DefaultPropertyFlags, 28),
        // property 'totalOutgoingRate'
        QtMocHelpers::PropertyData<double>(268, QMetaType::Double, QMC::DefaultPropertyFlags, 28),
        // property 'overallDirStatistics'
        QtMocHelpers::PropertyData<Data::SyncthingOverallDirStatistics>(269, 0x80000000 | 270, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 14),
        // property 'overallRemoteCompletion'
        QtMocHelpers::PropertyData<Data::SyncthingCompletion>(271, 0x80000000 | 185, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 15),
        // property 'lastSyncedFile'
        QtMocHelpers::PropertyData<QString>(272, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'syncthingVersion'
        QtMocHelpers::PropertyData<QString>(273, QMetaType::QString, QMC::DefaultPropertyFlags),
        // property 'lastSyncTime'
        QtMocHelpers::PropertyData<CppUtilities::DateTime>(274, 0x80000000 | 39, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'expectedSslErrors'
        QtMocHelpers::PropertyData<QList<QSslError>>(275, 0x80000000 | 226, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'connectedDevices'
        QtMocHelpers::PropertyData<std::vector<const SyncthingDev*>>(276, 0x80000000 | 277, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'directoryIds'
        QtMocHelpers::PropertyData<QStringList>(278, QMetaType::QStringList, QMC::DefaultPropertyFlags, 3),
        // property 'deviceIds'
        QtMocHelpers::PropertyData<QStringList>(279, QMetaType::QStringList, QMC::DefaultPropertyFlags, 4),
        // property 'guiRequiringAuth'
        QtMocHelpers::PropertyData<bool>(280, QMetaType::Bool, QMC::DefaultPropertyFlags, 2),
        // property 'rawConfig'
        QtMocHelpers::PropertyData<QJsonObject>(8, 0x80000000 | 7, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 2),
        // property 'useDeprecatedRoutes'
        QtMocHelpers::PropertyData<bool>(281, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'pausingOnMeteredConnection'
        QtMocHelpers::PropertyData<bool>(282, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'forceSuspendEnabled'
        QtMocHelpers::PropertyData<bool>(283, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'insecure'
        QtMocHelpers::PropertyData<bool>(284, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<SyncthingConnection, qt_meta_tag_ZN4Data19SyncthingConnectionE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Data::SyncthingConnection::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Data19SyncthingConnectionE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN4Data19SyncthingConnectionE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN4Data19SyncthingConnectionE_t>.metaTypes,
    nullptr
} };

void Data::SyncthingConnection::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<SyncthingConnection *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->syncthingUrlChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->autoReconnectIntervalChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 2: _t->newConfig((*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[1]))); break;
        case 3: _t->newDirs((*reinterpret_cast<std::add_pointer_t<std::vector<Data::SyncthingDir>>>(_a[1]))); break;
        case 4: _t->newDevices((*reinterpret_cast<std::add_pointer_t<std::vector<Data::SyncthingDev>>>(_a[1]))); break;
        case 5: _t->newErrors((*reinterpret_cast<std::add_pointer_t<std::vector<Data::SyncthingError>>>(_a[1]))); break;
        case 6: _t->beforeNewErrors((*reinterpret_cast<std::add_pointer_t<std::vector<Data::SyncthingError>>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<std::vector<Data::SyncthingError>>>(_a[2]))); break;
        case 7: _t->newConfigApplied(); break;
        case 8: _t->newEvents((*reinterpret_cast<std::add_pointer_t<QJsonArray>>(_a[1]))); break;
        case 9: _t->allEventsProcessed(); break;
        case 10: _t->dirStatusChanged((*reinterpret_cast<std::add_pointer_t<Data::SyncthingDir>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 11: _t->devStatusChanged((*reinterpret_cast<std::add_pointer_t<Data::SyncthingDev>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 12: _t->fileChanged((*reinterpret_cast<std::add_pointer_t<Data::SyncthingDir>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingFileChange>>(_a[3]))); break;
        case 13: _t->downloadProgressChanged(); break;
        case 14: _t->dirStatisticsChanged(); break;
        case 15: _t->devCompletionChanged(); break;
        case 16: _t->dirCompleted((*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingDir>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<const Data::SyncthingDev*>>(_a[4]))); break;
        case 17: _t->dirCompleted((*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingDir>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 18: _t->newNotification((*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 19: _t->newDevAvailable((*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 20: _t->newDirAvailable((*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<const Data::SyncthingDev*>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[5]))); break;
        case 21: _t->error((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingErrorCategory>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QNetworkRequest>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[5]))); break;
        case 22: _t->error((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingErrorCategory>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QNetworkRequest>>(_a[4]))); break;
        case 23: _t->error((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingErrorCategory>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 24: _t->statusChanged((*reinterpret_cast<std::add_pointer_t<Data::SyncthingStatus>>(_a[1]))); break;
        case 25: _t->configDirChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 26: _t->myIdChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 27: _t->tildeChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 28: _t->trafficChanged((*reinterpret_cast<std::add_pointer_t<std::uint64_t>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<std::uint64_t>>(_a[2]))); break;
        case 29: _t->newConfigTriggered(); break;
        case 30: _t->rescanTriggered((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 31: _t->devicePauseTriggered((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 32: _t->deviceResumeTriggered((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 33: _t->directoryPauseTriggered((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 34: _t->directoryResumeTriggered((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 35: _t->suspensionOrResumeTriggered((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 36: _t->restartTriggered(); break;
        case 37: _t->shutdownTriggered(); break;
        case 38: _t->errorsCleared(); break;
        case 39: _t->logAvailable((*reinterpret_cast<std::add_pointer_t<std::vector<Data::SyncthingLogEntry>>>(_a[1]))); break;
        case 40: _t->qrCodeAvailable((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2]))); break;
        case 41: _t->overrideTriggered((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 42: _t->revertTriggered((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 43: _t->hasOutOfSyncDirsChanged(); break;
        case 44: _t->hasStateChanged(); break;
        case 45: { bool _r = _t->loadSelfSignedCertificate((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 46: { bool _r = _t->loadSelfSignedCertificate();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 47: _t->clearSelfSignedCertificate(); break;
        case 48: { bool _r = _t->applySettings((*reinterpret_cast<std::add_pointer_t<Data::SyncthingConnectionSettings&>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 49: _t->applyRawConfig(); break;
        case 50: _t->postRawConfig((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 51: _t->connect(); break;
        case 52: _t->connect((*reinterpret_cast<std::add_pointer_t<Data::SyncthingConnectionSettings&>>(_a[1]))); break;
        case 53: _t->connectLater((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 54: _t->disconnect(); break;
        case 55: _t->reconnect(); break;
        case 56: _t->reconnect((*reinterpret_cast<std::add_pointer_t<Data::SyncthingConnectionSettings&>>(_a[1]))); break;
        case 57: _t->reconnectLater((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 58: _t->abortAllRequests(); break;
        case 59: _t->clearConnectionCache(); break;
        case 60: { bool _r = _t->pauseDevice((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 61: { bool _r = _t->pauseAllDevs();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 62: { bool _r = _t->resumeDevice((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 63: { bool _r = _t->resumeAllDevs();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 64: { bool _r = _t->pauseDirectories((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 65: { bool _r = _t->pauseAllDirs();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 66: { bool _r = _t->resumeDirectories((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 67: { bool _r = _t->resumeAllDirs();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 68: _t->rescan((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 69: _t->rescan((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 70: _t->rescanAllDirs(); break;
        case 71: _t->restart(); break;
        case 72: _t->shutdown(); break;
        case 73: { bool _r = _t->suspendOrResume((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 74: { bool _r = _t->suspendOrResume();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 75: _t->changeStatus(); break;
        case 76: _t->requestConfig(); break;
        case 77: _t->requestStatus(); break;
        case 78: _t->requestConfigAndStatus(); break;
        case 79: _t->requestEvents(); break;
        case 80: _t->requestErrors(); break;
        case 81: _t->requestConnections(); break;
        case 82: _t->requestClearingErrors(); break;
        case 83: _t->requestDirStatistics(); break;
        case 84: _t->requestDirStatus((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 85: _t->requestDirPullErrors((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 86: _t->requestDirPullErrors((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 87: _t->requestDirPullErrors((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 88: _t->requestCompletion((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 89: _t->requestDeviceStatistics(); break;
        case 90: _t->requestVersion(); break;
        case 91: _t->requestDiskEvents((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 92: _t->requestDiskEvents(); break;
        case 93: _t->requestQrCode((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 94: _t->requestLog(); break;
        case 95: _t->requestOverride((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 96: _t->requestRevert((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 97: _t->readConfig(); break;
        case 98: _t->readDirs((*reinterpret_cast<std::add_pointer_t<QJsonArray>>(_a[1]))); break;
        case 99: _t->readDevs((*reinterpret_cast<std::add_pointer_t<QJsonArray>>(_a[1]))); break;
        case 100: _t->readStatus(); break;
        case 101: _t->concludeReadingConfigAndStatus(); break;
        case 102: _t->readConnections(); break;
        case 103: _t->readDirStatistics(); break;
        case 104: _t->readDeviceStatistics(); break;
        case 105: _t->readErrors(); break;
        case 106: _t->readClearingErrors(); break;
        case 107: _t->readEvents(); break;
        case 108: { bool _r = _t->readEventsFromJsonArray((*reinterpret_cast<std::add_pointer_t<QJsonArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64&>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 109: _t->readStartingEvent((*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[1]))); break;
        case 110: _t->readStatusChangedEvent((*reinterpret_cast<std::add_pointer_t<SyncthingEventId>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[3]))); break;
        case 111: _t->readDownloadProgressEvent((*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[1]))); break;
        case 112: _t->readDirEvent((*reinterpret_cast<std::add_pointer_t<SyncthingEventId>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[4]))); break;
        case 113: _t->readDeviceEvent((*reinterpret_cast<std::add_pointer_t<SyncthingEventId>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[4]))); break;
        case 114: _t->readItemFinished((*reinterpret_cast<std::add_pointer_t<SyncthingEventId>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[3]))); break;
        case 115: _t->readFolderErrors((*reinterpret_cast<std::add_pointer_t<SyncthingEventId>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingDir&>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[5]))); break;
        case 116: _t->readFolderCompletion((*reinterpret_cast<std::add_pointer_t<SyncthingEventId>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingDir*>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[6]))); break;
        case 117: _t->readFolderCompletion((*reinterpret_cast<std::add_pointer_t<SyncthingEventId>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingDev*>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingDir*>>(_a[8])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[9]))); break;
        case 118: _t->readLocalFolderCompletion((*reinterpret_cast<std::add_pointer_t<SyncthingEventId>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingDir&>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[5]))); break;
        case 119: _t->readRemoteFolderCompletion((*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingDev*>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingDir*>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[8]))); break;
        case 120: _t->readRemoteFolderCompletion((*reinterpret_cast<std::add_pointer_t<Data::SyncthingCompletion>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingDev*>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingDir*>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[7]))); break;
        case 121: _t->readRemoteIndexUpdated((*reinterpret_cast<std::add_pointer_t<SyncthingEventId>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[2]))); break;
        case 122: _t->readRescan(); break;
        case 123: _t->readDevPauseResume(); break;
        case 124: _t->readDirPauseResume(); break;
        case 125: _t->readRestart(); break;
        case 126: _t->readShutdown(); break;
        case 127: _t->readSuspend(); break;
        case 128: _t->readDirStatus(); break;
        case 129: _t->readDirPullErrors(); break;
        case 130: _t->readDirSummary((*reinterpret_cast<std::add_pointer_t<SyncthingEventId>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingDir&>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[5]))); break;
        case 131: _t->readDirRejected((*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[3]))); break;
        case 132: _t->readDevRejected((*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[3]))); break;
        case 133: _t->readCompletion(); break;
        case 134: _t->readVersion(); break;
        case 135: _t->readDiskEvents(); break;
        case 136: _t->readChangeEvent((*reinterpret_cast<std::add_pointer_t<CppUtilities::DateTime>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QJsonObject>>(_a[3]))); break;
        case 137: _t->readLog(); break;
        case 138: _t->readQrCode(); break;
        case 139: _t->readOverride(); break;
        case 140: _t->readRevert(); break;
        case 141: _t->continueConnecting(); break;
        case 142: _t->continueReconnecting(); break;
        case 143: _t->autoReconnect(); break;
        case 144: { bool _r = _t->setStatus((*reinterpret_cast<std::add_pointer_t<Data::SyncthingStatus>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 145: _t->emitError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QJsonParseError>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QNetworkReply*>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[4]))); break;
        case 146: _t->emitError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<Data::SyncthingErrorCategory>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QNetworkReply*>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[4]))); break;
        case 147: _t->emitError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QNetworkReply*>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[3]))); break;
        case 148: _t->emitMyIdChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 149: _t->emitTildeChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 150: _t->handleFatalConnectionError(); break;
        case 151: _t->handleAdditionalRequestCanceled(); break;
        case 152: _t->handleSslErrors((*reinterpret_cast<std::add_pointer_t<QList<QSslError>>>(_a[1]))); break;
        case 153: _t->handleRedirection((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 154: { bool _r = _t->handleMeteredConnection();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 155: _t->recalculateStatus(); break;
        case 156: _t->invalidateHasOutOfSyncDirs(); break;
        case 157: { QUrl _r = _t->makeUrlWithCredentials();
            if (_a[0]) *reinterpret_cast<QUrl*>(_a[0]) = std::move(_r); }  break;
        case 158: { QString _r = _t->substituteTilde((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 159: { QString _r = _t->deviceNameOrId((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 160: { QString _r = _t->fullPath((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 10:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Data::SyncthingDir >(); break;
            }
            break;
        case 11:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Data::SyncthingDev >(); break;
            }
            break;
        case 12:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Data::SyncthingDir >(); break;
            }
            break;
        case 16:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Data::SyncthingDir >(); break;
            }
            break;
        case 17:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< Data::SyncthingDir >(); break;
            }
            break;
        case 21:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 3:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QNetworkRequest >(); break;
            }
            break;
        case 22:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 3:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QNetworkRequest >(); break;
            }
            break;
        case 152:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<QSslError> >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QString & )>(_a, &SyncthingConnection::syncthingUrlChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(int )>(_a, &SyncthingConnection::autoReconnectIntervalChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QJsonObject & )>(_a, &SyncthingConnection::newConfig, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const std::vector<Data::SyncthingDir> & )>(_a, &SyncthingConnection::newDirs, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const std::vector<Data::SyncthingDev> & )>(_a, &SyncthingConnection::newDevices, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const std::vector<Data::SyncthingError> & )>(_a, &SyncthingConnection::newErrors, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const std::vector<Data::SyncthingError> & , const std::vector<Data::SyncthingError> & )>(_a, &SyncthingConnection::beforeNewErrors, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)()>(_a, &SyncthingConnection::newConfigApplied, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QJsonArray & )>(_a, &SyncthingConnection::newEvents, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)()>(_a, &SyncthingConnection::allEventsProcessed, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const Data::SyncthingDir & , int )>(_a, &SyncthingConnection::dirStatusChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const Data::SyncthingDev & , int )>(_a, &SyncthingConnection::devStatusChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const Data::SyncthingDir & , int , const Data::SyncthingFileChange & )>(_a, &SyncthingConnection::fileChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)()>(_a, &SyncthingConnection::downloadProgressChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)()>(_a, &SyncthingConnection::dirStatisticsChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)()>(_a, &SyncthingConnection::devCompletionChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(CppUtilities::DateTime , const Data::SyncthingDir & , int , const Data::SyncthingDev * )>(_a, &SyncthingConnection::dirCompleted, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(CppUtilities::DateTime , const QString & )>(_a, &SyncthingConnection::newNotification, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(CppUtilities::DateTime , const QString & , const QString & )>(_a, &SyncthingConnection::newDevAvailable, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(CppUtilities::DateTime , const QString & , const Data::SyncthingDev * , const QString & , const QString & )>(_a, &SyncthingConnection::newDirAvailable, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QString & , Data::SyncthingErrorCategory , int , const QNetworkRequest & , const QByteArray & )>(_a, &SyncthingConnection::error, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(Data::SyncthingStatus )>(_a, &SyncthingConnection::statusChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QString & )>(_a, &SyncthingConnection::configDirChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QString & )>(_a, &SyncthingConnection::myIdChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QString & )>(_a, &SyncthingConnection::tildeChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(std::uint64_t , std::uint64_t )>(_a, &SyncthingConnection::trafficChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)()>(_a, &SyncthingConnection::newConfigTriggered, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QString & )>(_a, &SyncthingConnection::rescanTriggered, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QStringList & )>(_a, &SyncthingConnection::devicePauseTriggered, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QStringList & )>(_a, &SyncthingConnection::deviceResumeTriggered, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QStringList & )>(_a, &SyncthingConnection::directoryPauseTriggered, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QStringList & )>(_a, &SyncthingConnection::directoryResumeTriggered, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(bool )>(_a, &SyncthingConnection::suspensionOrResumeTriggered, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)()>(_a, &SyncthingConnection::restartTriggered, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)()>(_a, &SyncthingConnection::shutdownTriggered, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)()>(_a, &SyncthingConnection::errorsCleared, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const std::vector<Data::SyncthingLogEntry> & )>(_a, &SyncthingConnection::logAvailable, 39))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QString & , const QByteArray & )>(_a, &SyncthingConnection::qrCodeAvailable, 40))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QString & )>(_a, &SyncthingConnection::overrideTriggered, 41))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)(const QString & )>(_a, &SyncthingConnection::revertTriggered, 42))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)()>(_a, &SyncthingConnection::hasOutOfSyncDirsChanged, 43))
            return;
        if (QtMocHelpers::indexOfMethod<void (SyncthingConnection::*)()>(_a, &SyncthingConnection::hasStateChanged, 44))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 34:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Data::SyncthingOverallDirStatistics >(); break;
        case 39:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<QSslError> >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->syncthingUrl(); break;
        case 1: *reinterpret_cast<QUrl*>(_v) = _t->makeUrlWithCredentials(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->localPath(); break;
        case 3: *reinterpret_cast<QByteArray*>(_v) = _t->apiKey(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->isLocal(); break;
        case 5: *reinterpret_cast<QString*>(_v) = _t->user(); break;
        case 6: *reinterpret_cast<QString*>(_v) = _t->password(); break;
        case 7: *reinterpret_cast<Data::SyncthingStatus*>(_v) = _t->status(); break;
        case 8: *reinterpret_cast<Data::SyncthingStatusComputionFlags*>(_v) = _t->statusComputionFlags(); break;
        case 9: *reinterpret_cast<Data::SyncthingConnectionLoggingFlags*>(_v) = _t->loggingFlags(); break;
        case 10: *reinterpret_cast<QString*>(_v) = _t->statusText(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->isConnected(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->isConnecting(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->isAborted(); break;
        case 14: *reinterpret_cast<bool*>(_v) = _t->hasErrors(); break;
        case 15: *reinterpret_cast<bool*>(_v) = _t->hasOutOfSyncDirs(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->hasState(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->isRequestingCompletionEnabled(); break;
        case 18: *reinterpret_cast<int*>(_v) = _t->autoReconnectInterval(); break;
        case 19: *reinterpret_cast<uint*>(_v) = _t->autoReconnectTries(); break;
        case 20: *reinterpret_cast<int*>(_v) = _t->trafficPollInterval(); break;
        case 21: *reinterpret_cast<int*>(_v) = _t->devStatsPollInterval(); break;
        case 22: *reinterpret_cast<bool*>(_v) = _t->recordFileChanges(); break;
        case 23: *reinterpret_cast<int*>(_v) = _t->requestTimeout(); break;
        case 24: *reinterpret_cast<int*>(_v) = _t->longPollingTimeout(); break;
        case 25: *reinterpret_cast<int*>(_v) = _t->diskEventLimit(); break;
        case 26: *reinterpret_cast<QString*>(_v) = _t->myId(); break;
        case 27: *reinterpret_cast<QString*>(_v) = _t->tilde(); break;
        case 28: *reinterpret_cast<QString*>(_v) = _t->pathSeparator(); break;
        case 29: *reinterpret_cast<QString*>(_v) = _t->configDir(); break;
        case 30: *reinterpret_cast<quint64*>(_v) = _t->totalIncomingTraffic(); break;
        case 31: *reinterpret_cast<quint64*>(_v) = _t->totalOutgoingTraffic(); break;
        case 32: *reinterpret_cast<double*>(_v) = _t->totalIncomingRate(); break;
        case 33: *reinterpret_cast<double*>(_v) = _t->totalOutgoingRate(); break;
        case 34: *reinterpret_cast<Data::SyncthingOverallDirStatistics*>(_v) = _t->computeOverallDirStatistics(); break;
        case 35: *reinterpret_cast<Data::SyncthingCompletion*>(_v) = _t->computeOverallRemoteCompletion(); break;
        case 36: *reinterpret_cast<QString*>(_v) = _t->lastSyncedFile(); break;
        case 37: *reinterpret_cast<QString*>(_v) = _t->syncthingVersion(); break;
        case 38: *reinterpret_cast<CppUtilities::DateTime*>(_v) = _t->lastSyncTime(); break;
        case 39: *reinterpret_cast<QList<QSslError>*>(_v) = _t->expectedSslErrors(); break;
        case 40: *reinterpret_cast<std::vector<const SyncthingDev*>*>(_v) = _t->connectedDevices(); break;
        case 41: *reinterpret_cast<QStringList*>(_v) = _t->directoryIds(); break;
        case 42: *reinterpret_cast<QStringList*>(_v) = _t->deviceIds(); break;
        case 43: *reinterpret_cast<bool*>(_v) = _t->isGuiRequiringAuth(); break;
        case 44: *reinterpret_cast<QJsonObject*>(_v) = _t->rawConfig(); break;
        case 45: *reinterpret_cast<bool*>(_v) = _t->isUsingDeprecatedRoutes(); break;
        case 46: *reinterpret_cast<bool*>(_v) = _t->isPausingOnMeteredConnection(); break;
        case 47: *reinterpret_cast<bool*>(_v) = _t->isForceSuspendEnabled(); break;
        case 48: *reinterpret_cast<bool*>(_v) = _t->isInsecure(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setSyncthingUrl(*reinterpret_cast<QString*>(_v)); break;
        case 2: _t->setLocalPath(*reinterpret_cast<QString*>(_v)); break;
        case 3: _t->setApiKey(*reinterpret_cast<QByteArray*>(_v)); break;
        case 8: _t->setStatusComputionFlags(*reinterpret_cast<Data::SyncthingStatusComputionFlags*>(_v)); break;
        case 9: _t->setLoggingFlags(*reinterpret_cast<Data::SyncthingConnectionLoggingFlags*>(_v)); break;
        case 17: _t->setRequestingCompletionEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 18: _t->setAutoReconnectInterval(*reinterpret_cast<int*>(_v)); break;
        case 20: _t->setTrafficPollInterval(*reinterpret_cast<int*>(_v)); break;
        case 21: _t->setDevStatsPollInterval(*reinterpret_cast<int*>(_v)); break;
        case 22: _t->setRecordFileChanges(*reinterpret_cast<bool*>(_v)); break;
        case 23: _t->setRequestTimeout(*reinterpret_cast<int*>(_v)); break;
        case 24: _t->setLongPollingTimeout(*reinterpret_cast<int*>(_v)); break;
        case 25: _t->setDiskEventLimit(*reinterpret_cast<int*>(_v)); break;
        case 45: _t->setUseDeprecatedRoutes(*reinterpret_cast<bool*>(_v)); break;
        case 46: _t->setPausingOnMeteredConnection(*reinterpret_cast<bool*>(_v)); break;
        case 47: _t->setForceSuspendEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 48: _t->setInsecure(*reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}

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

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

int Data::SyncthingConnection::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 < 161)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 161;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 161)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 161;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 49;
    }
    return _id;
}

// SIGNAL 0
void Data::SyncthingConnection::syncthingUrlChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void Data::SyncthingConnection::autoReconnectIntervalChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void Data::SyncthingConnection::newConfig(const QJsonObject & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void Data::SyncthingConnection::newDirs(const std::vector<Data::SyncthingDir> & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void Data::SyncthingConnection::newDevices(const std::vector<Data::SyncthingDev> & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void Data::SyncthingConnection::newErrors(const std::vector<Data::SyncthingError> & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void Data::SyncthingConnection::beforeNewErrors(const std::vector<Data::SyncthingError> & _t1, const std::vector<Data::SyncthingError> & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1, _t2);
}

// SIGNAL 7
void Data::SyncthingConnection::newConfigApplied()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void Data::SyncthingConnection::newEvents(const QJsonArray & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void Data::SyncthingConnection::allEventsProcessed()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void Data::SyncthingConnection::dirStatusChanged(const Data::SyncthingDir & _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1, _t2);
}

// SIGNAL 11
void Data::SyncthingConnection::devStatusChanged(const Data::SyncthingDev & _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2);
}

// SIGNAL 12
void Data::SyncthingConnection::fileChanged(const Data::SyncthingDir & _t1, int _t2, const Data::SyncthingFileChange & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1, _t2, _t3);
}

// SIGNAL 13
void Data::SyncthingConnection::downloadProgressChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void Data::SyncthingConnection::dirStatisticsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void Data::SyncthingConnection::devCompletionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void Data::SyncthingConnection::dirCompleted(CppUtilities::DateTime _t1, const Data::SyncthingDir & _t2, int _t3, const Data::SyncthingDev * _t4)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1, _t2, _t3, _t4);
}

// SIGNAL 18
void Data::SyncthingConnection::newNotification(CppUtilities::DateTime _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1, _t2);
}

// SIGNAL 19
void Data::SyncthingConnection::newDevAvailable(CppUtilities::DateTime _t1, const QString & _t2, const QString & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1, _t2, _t3);
}

// SIGNAL 20
void Data::SyncthingConnection::newDirAvailable(CppUtilities::DateTime _t1, const QString & _t2, const Data::SyncthingDev * _t3, const QString & _t4, const QString & _t5)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1, _t2, _t3, _t4, _t5);
}

// SIGNAL 21
void Data::SyncthingConnection::error(const QString & _t1, Data::SyncthingErrorCategory _t2, int _t3, const QNetworkRequest & _t4, const QByteArray & _t5)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1, _t2, _t3, _t4, _t5);
}

// SIGNAL 24
void Data::SyncthingConnection::statusChanged(Data::SyncthingStatus _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void Data::SyncthingConnection::configDirChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void Data::SyncthingConnection::myIdChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void Data::SyncthingConnection::tildeChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1);
}

// SIGNAL 28
void Data::SyncthingConnection::trafficChanged(std::uint64_t _t1, std::uint64_t _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1, _t2);
}

// SIGNAL 29
void Data::SyncthingConnection::newConfigTriggered()
{
    QMetaObject::activate(this, &staticMetaObject, 29, nullptr);
}

// SIGNAL 30
void Data::SyncthingConnection::rescanTriggered(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1);
}

// SIGNAL 31
void Data::SyncthingConnection::devicePauseTriggered(const QStringList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1);
}

// SIGNAL 32
void Data::SyncthingConnection::deviceResumeTriggered(const QStringList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 32, nullptr, _t1);
}

// SIGNAL 33
void Data::SyncthingConnection::directoryPauseTriggered(const QStringList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 33, nullptr, _t1);
}

// SIGNAL 34
void Data::SyncthingConnection::directoryResumeTriggered(const QStringList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1);
}

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

// SIGNAL 36
void Data::SyncthingConnection::restartTriggered()
{
    QMetaObject::activate(this, &staticMetaObject, 36, nullptr);
}

// SIGNAL 37
void Data::SyncthingConnection::shutdownTriggered()
{
    QMetaObject::activate(this, &staticMetaObject, 37, nullptr);
}

// SIGNAL 38
void Data::SyncthingConnection::errorsCleared()
{
    QMetaObject::activate(this, &staticMetaObject, 38, nullptr);
}

// SIGNAL 39
void Data::SyncthingConnection::logAvailable(const std::vector<Data::SyncthingLogEntry> & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 39, nullptr, _t1);
}

// SIGNAL 40
void Data::SyncthingConnection::qrCodeAvailable(const QString & _t1, const QByteArray & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 40, nullptr, _t1, _t2);
}

// SIGNAL 41
void Data::SyncthingConnection::overrideTriggered(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 41, nullptr, _t1);
}

// SIGNAL 42
void Data::SyncthingConnection::revertTriggered(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 42, nullptr, _t1);
}

// SIGNAL 43
void Data::SyncthingConnection::hasOutOfSyncDirsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 43, nullptr);
}

// SIGNAL 44
void Data::SyncthingConnection::hasStateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 44, nullptr);
}
QT_WARNING_POP
