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

#include "../../../rpi-imager/src/imagewriter.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 'imagewriter.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.0. 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_ZN11ImageWriterE_t {};
} // unnamed namespace

template <> constexpr inline auto ImageWriter::qt_create_metaobjectdata<qt_meta_tag_ZN11ImageWriterE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ImageWriter",
        "QML.Element",
        "auto",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "Created by C++",
        "downloadProgress",
        "",
        "QVariant",
        "dlnow",
        "dltotal",
        "writeProgress",
        "now",
        "total",
        "verifyProgress",
        "error",
        "msg",
        "success",
        "fileSelected",
        "filename",
        "cancelled",
        "finalizing",
        "networkOnline",
        "preparationStatusUpdate",
        "osListPrepared",
        "bottleneckStatusChanged",
        "status",
        "throughputKBps",
        "operationWarning",
        "message",
        "hwFilterChanged",
        "networkInfo",
        "cacheVerificationStarted",
        "cacheVerificationFinished",
        "selectedDeviceRemoved",
        "writeCancelledDueToDeviceRemoval",
        "keychainPermissionRequested",
        "keychainPermissionResponseReceived",
        "writeStateChanged",
        "connectTokenReceived",
        "token",
        "connectTokenConflictDetected",
        "connectTokenCleared",
        "repositoryUrlReceived",
        "url",
        "customRepoChanged",
        "customRepoHostChanged",
        "cacheStatusChanged",
        "osListUnavailableChanged",
        "permissionWarning",
        "locationPermissionGranted",
        "performanceSaveDialogNeeded",
        "suggestedFilename",
        "initialDir",
        "startProgressPolling",
        "stopProgressPolling",
        "pollNetwork",
        "restartWrite",
        "reason",
        "onSuccess",
        "onError",
        "onFileSelected",
        "onCancelled",
        "onFinalizing",
        "onPreparationStatusUpdate",
        "onOsListFetchComplete",
        "data",
        "QUrl",
        "effectiveUrl",
        "onOsListFetchError",
        "errorMessage",
        "onNetworkConnectionStats",
        "statsMetadata",
        "onSTPdetected",
        "onCacheVerificationProgress",
        "bytesProcessed",
        "totalBytes",
        "onCacheVerificationComplete",
        "isValid",
        "onSelectedDeviceRemoved",
        "device",
        "onOsListRefreshTimeout",
        "onRpibootFastbootReady",
        "fastbootId",
        "onRpibootError",
        "onRpibootDeviceDetected",
        "deviceId",
        "uint8_t",
        "busNumber",
        "deviceAddress",
        "QList<uint8_t>",
        "portPath",
        "uint16_t",
        "productId",
        "onBootstrapComplete",
        "portPathKey",
        "onBootstrapError",
        "isExtractSizeKnown",
        "setSrc",
        "downloadLen",
        "extrLen",
        "expectedHash",
        "multifilesinzip",
        "parentcategory",
        "osname",
        "initFormat",
        "releaseDate",
        "bmapUrl",
        "setDst",
        "deviceSize",
        "setVerifyEnabled",
        "verify",
        "setCustomRepo",
        "repo",
        "setCustomCacheFile",
        "cacheFile",
        "sha256",
        "readyToWrite",
        "isRaspberryPiDevice",
        "getHardwareName",
        "createHardwareTags",
        "startWrite",
        "cancelWrite",
        "skipCacheVerification",
        "skipCurrentVerification",
        "isCached",
        "getDriveList",
        "DriveListModel*",
        "getHWList",
        "HWListModel*",
        "getOSList",
        "OSListModel*",
        "fileNameFromUrl",
        "osListUrlForDisplay",
        "osListUrl",
        "constantVersion",
        "isVersionNewer",
        "version",
        "setCustomOsListUrl",
        "getFilteredOSlist",
        "getFilteredOSlistDocument",
        "QJsonDocument",
        "beginOSListFetch",
        "setHWFilterList",
        "QJsonArray",
        "tags",
        "inclusive",
        "setHWCapabilitiesList",
        "json",
        "setSWCapabilitiesList",
        "QVariantList",
        "caps",
        "getHWFilterList",
        "getHWFilterListInclusive",
        "checkHWAndSWCapability",
        "cap",
        "differentSWCap",
        "checkHWCapability",
        "checkSWCapability",
        "openFileDialog",
        "title",
        "filter",
        "nativeFileDialogAvailable",
        "acceptCustomImageFromQml",
        "fileUrl",
        "getNativeOpenFileName",
        "setMainWindow",
        "window",
        "readFileContents",
        "filePath",
        "keychainPermissionResponse",
        "granted",
        "srcFileName",
        "getSelectedSourceSize",
        "formatSize",
        "bytes",
        "decimals",
        "isOnline",
        "isEmbeddedMode",
        "hasWindowDecorations",
        "mountUsbSourceMedia",
        "getUsbSourceOSlist",
        "getDefaultPubKey",
        "hasPubKey",
        "hasSshKeyGen",
        "generatePubKey",
        "getTimezone",
        "getTimezoneList",
        "getCountryList",
        "getKeymapLayoutList",
        "getCapitalCitiesList",
        "getLocaleDataForCapital",
        "QVariantMap",
        "capitalCity",
        "getSSID",
        "getPSK",
        "getPSKForSSID",
        "ssid",
        "getBoolSetting",
        "key",
        "getStringSetting",
        "setSetting",
        "value",
        "getRsaKeyFingerprint",
        "keyPath",
        "getDebugDirectIO",
        "setDebugDirectIO",
        "enabled",
        "getDebugPeriodicSync",
        "setDebugPeriodicSync",
        "getDebugVerboseLogging",
        "setDebugVerboseLogging",
        "getDebugAsyncIO",
        "setDebugAsyncIO",
        "getDebugAsyncQueueDepth",
        "setDebugAsyncQueueDepth",
        "depth",
        "getDebugIPv4Only",
        "setDebugIPv4Only",
        "getDebugSkipEndOfDevice",
        "setDebugSkipEndOfDevice",
        "getDebugRpiboot",
        "setDebugRpiboot",
        "getDebugCustomFastbootGadget",
        "setDebugCustomFastbootGadget",
        "path",
        "applyCustomisationFromSettings",
        "settings",
        "setImageCustomisation",
        "config",
        "cmdline",
        "firstrun",
        "cloudinit",
        "cloudinitNetwork",
        "ImageOptions::AdvancedOptions",
        "opts",
        "setSavedCustomisationSettings",
        "map",
        "getSavedCustomisationSettings",
        "setPersistedCustomisationSetting",
        "removePersistedCustomisationSetting",
        "clearSavedCustomisationSettings",
        "imageSupportsCustomization",
        "imageSupportsCcRpi",
        "crypt",
        "password",
        "pbkdf2",
        "psk",
        "getTranslations",
        "getCurrentLanguage",
        "getCurrentKeyboard",
        "getCurrentUser",
        "changeLanguage",
        "newLanguageName",
        "changeKeyboard",
        "newKeymapLayout",
        "customRepo",
        "customRepoHost",
        "isValidRepoUrl",
        "isSecureBootForcedByCliFlag",
        "hasMouse",
        "reboot",
        "openUrl",
        "isScreenReaderActive",
        "handleIncomingUrl",
        "overwriteConnectToken",
        "getRuntimeConnectToken",
        "verifyAuthKey",
        "strict",
        "clearConnectToken",
        "setOsListRefreshOverride",
        "intervalMinutes",
        "jitterMinutes",
        "refreshOsListFrom",
        "refreshOsListFromDefaultUrl",
        "isElevatableBundle",
        "hasElevationPolicyInstalled",
        "installElevationPolicy",
        "restartWithElevatedPrivileges",
        "isBeepAvailable",
        "setRpibootDevice",
        "isRpibootDevice",
        "setFastbootDevice",
        "size",
        "exportPerformanceData",
        "exportPerformanceDataToFile",
        "getPerformanceDataFilename",
        "hasPerformanceData",
        "writeState",
        "WriteState",
        "isOsListUnavailable",
        "Idle",
        "Preparing",
        "Writing",
        "Verifying",
        "Finalizing",
        "Cancelling",
        "Succeeded",
        "Failed",
        "Cancelled"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'downloadProgress'
        QtMocHelpers::SignalData<void(QVariant, QVariant)>(7, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 10 }, { 0x80000000 | 9, 11 },
        }}),
        // Signal 'writeProgress'
        QtMocHelpers::SignalData<void(QVariant, QVariant)>(12, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 13 }, { 0x80000000 | 9, 14 },
        }}),
        // Signal 'verifyProgress'
        QtMocHelpers::SignalData<void(QVariant, QVariant)>(15, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 13 }, { 0x80000000 | 9, 14 },
        }}),
        // Signal 'error'
        QtMocHelpers::SignalData<void(QVariant)>(16, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 17 },
        }}),
        // Signal 'success'
        QtMocHelpers::SignalData<void()>(18, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fileSelected'
        QtMocHelpers::SignalData<void(QVariant)>(19, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 20 },
        }}),
        // Signal 'cancelled'
        QtMocHelpers::SignalData<void()>(21, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'finalizing'
        QtMocHelpers::SignalData<void()>(22, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'networkOnline'
        QtMocHelpers::SignalData<void()>(23, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'preparationStatusUpdate'
        QtMocHelpers::SignalData<void(QVariant)>(24, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 17 },
        }}),
        // Signal 'osListPrepared'
        QtMocHelpers::SignalData<void()>(25, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'bottleneckStatusChanged'
        QtMocHelpers::SignalData<void(QVariant, QVariant)>(26, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 27 }, { 0x80000000 | 9, 28 },
        }}),
        // Signal 'operationWarning'
        QtMocHelpers::SignalData<void(QVariant)>(29, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 30 },
        }}),
        // Signal 'hwFilterChanged'
        QtMocHelpers::SignalData<void()>(31, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'networkInfo'
        QtMocHelpers::SignalData<void(QVariant)>(32, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 17 },
        }}),
        // Signal 'cacheVerificationStarted'
        QtMocHelpers::SignalData<void()>(33, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'cacheVerificationFinished'
        QtMocHelpers::SignalData<void()>(34, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'selectedDeviceRemoved'
        QtMocHelpers::SignalData<void()>(35, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'writeCancelledDueToDeviceRemoval'
        QtMocHelpers::SignalData<void()>(36, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'keychainPermissionRequested'
        QtMocHelpers::SignalData<void()>(37, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'keychainPermissionResponseReceived'
        QtMocHelpers::SignalData<void()>(38, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'writeStateChanged'
        QtMocHelpers::SignalData<void()>(39, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'connectTokenReceived'
        QtMocHelpers::SignalData<void(const QString &)>(40, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 41 },
        }}),
        // Signal 'connectTokenConflictDetected'
        QtMocHelpers::SignalData<void(const QString &)>(42, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 41 },
        }}),
        // Signal 'connectTokenCleared'
        QtMocHelpers::SignalData<void()>(43, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'repositoryUrlReceived'
        QtMocHelpers::SignalData<void(const QString &)>(44, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 45 },
        }}),
        // Signal 'customRepoChanged'
        QtMocHelpers::SignalData<void()>(46, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'customRepoHostChanged'
        QtMocHelpers::SignalData<void()>(47, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'cacheStatusChanged'
        QtMocHelpers::SignalData<void()>(48, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'osListUnavailableChanged'
        QtMocHelpers::SignalData<void()>(49, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'permissionWarning'
        QtMocHelpers::SignalData<void(QVariant)>(50, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 9, 17 },
        }}),
        // Signal 'locationPermissionGranted'
        QtMocHelpers::SignalData<void()>(51, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'performanceSaveDialogNeeded'
        QtMocHelpers::SignalData<void(const QString &, const QString &)>(52, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 53 }, { QMetaType::QString, 54 },
        }}),
        // Slot 'startProgressPolling'
        QtMocHelpers::SlotData<void()>(55, 8, QMC::AccessProtected, QMetaType::Void),
        // Slot 'stopProgressPolling'
        QtMocHelpers::SlotData<void()>(56, 8, QMC::AccessProtected, QMetaType::Void),
        // Slot 'pollNetwork'
        QtMocHelpers::SlotData<void()>(57, 8, QMC::AccessProtected, QMetaType::Void),
        // Slot 'restartWrite'
        QtMocHelpers::SlotData<void(QString)>(58, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 59 },
        }}),
        // Slot 'onSuccess'
        QtMocHelpers::SlotData<void()>(60, 8, QMC::AccessProtected, QMetaType::Void),
        // Slot 'onError'
        QtMocHelpers::SlotData<void(QString)>(61, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Slot 'onFileSelected'
        QtMocHelpers::SlotData<void(QString)>(62, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 20 },
        }}),
        // Slot 'onCancelled'
        QtMocHelpers::SlotData<void()>(63, 8, QMC::AccessProtected, QMetaType::Void),
        // Slot 'onFinalizing'
        QtMocHelpers::SlotData<void()>(64, 8, QMC::AccessProtected, QMetaType::Void),
        // Slot 'onPreparationStatusUpdate'
        QtMocHelpers::SlotData<void(QString)>(65, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Slot 'onOsListFetchComplete'
        QtMocHelpers::SlotData<void(const QByteArray &, const QUrl &, const QUrl &)>(66, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QByteArray, 67 }, { 0x80000000 | 68, 45 }, { 0x80000000 | 68, 69 },
        }}),
        // Slot 'onOsListFetchError'
        QtMocHelpers::SlotData<void(const QString &, const QUrl &)>(70, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 71 }, { 0x80000000 | 68, 45 },
        }}),
        // Slot 'onNetworkConnectionStats'
        QtMocHelpers::SlotData<void(const QString &, const QUrl &)>(72, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 73 }, { 0x80000000 | 68, 45 },
        }}),
        // Slot 'onSTPdetected'
        QtMocHelpers::SlotData<void()>(74, 8, QMC::AccessProtected, QMetaType::Void),
        // Slot 'onCacheVerificationProgress'
        QtMocHelpers::SlotData<void(qint64, qint64)>(75, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::LongLong, 76 }, { QMetaType::LongLong, 77 },
        }}),
        // Slot 'onCacheVerificationComplete'
        QtMocHelpers::SlotData<void(bool)>(78, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::Bool, 79 },
        }}),
        // Slot 'onSelectedDeviceRemoved'
        QtMocHelpers::SlotData<void(const QString &)>(80, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 81 },
        }}),
        // Slot 'onOsListRefreshTimeout'
        QtMocHelpers::SlotData<void()>(82, 8, QMC::AccessProtected, QMetaType::Void),
        // Slot 'onRpibootFastbootReady'
        QtMocHelpers::SlotData<void(const QString &)>(83, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 84 },
        }}),
        // Slot 'onRpibootError'
        QtMocHelpers::SlotData<void(const QString &)>(85, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Slot 'onRpibootDeviceDetected'
        QtMocHelpers::SlotData<void(const QString &, uint8_t, uint8_t, const QList<uint8_t> &, uint16_t)>(86, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 87 }, { 0x80000000 | 88, 89 }, { 0x80000000 | 88, 90 }, { 0x80000000 | 91, 92 },
            { 0x80000000 | 93, 94 },
        }}),
        // Slot 'onBootstrapComplete'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(95, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 96 }, { QMetaType::QString, 84 },
        }}),
        // Slot 'onBootstrapError'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(97, 8, QMC::AccessProtected, QMetaType::Void, {{
            { QMetaType::QString, 96 }, { QMetaType::QString, 17 },
        }}),
        // Method 'isExtractSizeKnown'
        QtMocHelpers::MethodData<bool() const>(98, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'setSrc'
        QtMocHelpers::MethodData<void(const QUrl &, quint64, quint64, QByteArray, bool, QString, QString, QByteArray, QString, QString)>(99, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 68, 45 }, { QMetaType::ULongLong, 100 }, { QMetaType::ULongLong, 101 }, { QMetaType::QByteArray, 102 },
            { QMetaType::Bool, 103 }, { QMetaType::QString, 104 }, { QMetaType::QString, 105 }, { QMetaType::QByteArray, 106 },
            { QMetaType::QString, 107 }, { QMetaType::QString, 108 },
        }}),
        // Method 'setSrc'
        QtMocHelpers::MethodData<void(const QUrl &, quint64, quint64, QByteArray, bool, QString, QString, QByteArray, QString)>(99, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 68, 45 }, { QMetaType::ULongLong, 100 }, { QMetaType::ULongLong, 101 }, { QMetaType::QByteArray, 102 },
            { QMetaType::Bool, 103 }, { QMetaType::QString, 104 }, { QMetaType::QString, 105 }, { QMetaType::QByteArray, 106 },
            { QMetaType::QString, 107 },
        }}),
        // Method 'setSrc'
        QtMocHelpers::MethodData<void(const QUrl &, quint64, quint64, QByteArray, bool, QString, QString, QByteArray)>(99, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 68, 45 }, { QMetaType::ULongLong, 100 }, { QMetaType::ULongLong, 101 }, { QMetaType::QByteArray, 102 },
            { QMetaType::Bool, 103 }, { QMetaType::QString, 104 }, { QMetaType::QString, 105 }, { QMetaType::QByteArray, 106 },
        }}),
        // Method 'setSrc'
        QtMocHelpers::MethodData<void(const QUrl &, quint64, quint64, QByteArray, bool, QString, QString)>(99, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 68, 45 }, { QMetaType::ULongLong, 100 }, { QMetaType::ULongLong, 101 }, { QMetaType::QByteArray, 102 },
            { QMetaType::Bool, 103 }, { QMetaType::QString, 104 }, { QMetaType::QString, 105 },
        }}),
        // Method 'setSrc'
        QtMocHelpers::MethodData<void(const QUrl &, quint64, quint64, QByteArray, bool, QString)>(99, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 68, 45 }, { QMetaType::ULongLong, 100 }, { QMetaType::ULongLong, 101 }, { QMetaType::QByteArray, 102 },
            { QMetaType::Bool, 103 }, { QMetaType::QString, 104 },
        }}),
        // Method 'setSrc'
        QtMocHelpers::MethodData<void(const QUrl &, quint64, quint64, QByteArray, bool)>(99, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 68, 45 }, { QMetaType::ULongLong, 100 }, { QMetaType::ULongLong, 101 }, { QMetaType::QByteArray, 102 },
            { QMetaType::Bool, 103 },
        }}),
        // Method 'setSrc'
        QtMocHelpers::MethodData<void(const QUrl &, quint64, quint64, QByteArray)>(99, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 68, 45 }, { QMetaType::ULongLong, 100 }, { QMetaType::ULongLong, 101 }, { QMetaType::QByteArray, 102 },
        }}),
        // Method 'setSrc'
        QtMocHelpers::MethodData<void(const QUrl &, quint64, quint64)>(99, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 68, 45 }, { QMetaType::ULongLong, 100 }, { QMetaType::ULongLong, 101 },
        }}),
        // Method 'setSrc'
        QtMocHelpers::MethodData<void(const QUrl &, quint64)>(99, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 68, 45 }, { QMetaType::ULongLong, 100 },
        }}),
        // Method 'setSrc'
        QtMocHelpers::MethodData<void(const QUrl &)>(99, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 68, 45 },
        }}),
        // Method 'setDst'
        QtMocHelpers::MethodData<void(const QString &, quint64)>(109, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 81 }, { QMetaType::ULongLong, 110 },
        }}),
        // Method 'setDst'
        QtMocHelpers::MethodData<void(const QString &)>(109, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 81 },
        }}),
        // Method 'setVerifyEnabled'
        QtMocHelpers::MethodData<void(bool)>(111, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 112 },
        }}),
        // Method 'setCustomRepo'
        QtMocHelpers::MethodData<void(const QUrl &)>(113, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 68, 114 },
        }}),
        // Method 'setCustomCacheFile'
        QtMocHelpers::MethodData<void(const QString &, const QByteArray &)>(115, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 116 }, { QMetaType::QByteArray, 117 },
        }}),
        // Method 'readyToWrite'
        QtMocHelpers::MethodData<bool()>(118, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'isRaspberryPiDevice'
        QtMocHelpers::MethodData<bool()>(119, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'getHardwareName'
        QtMocHelpers::MethodData<QString()>(120, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'createHardwareTags'
        QtMocHelpers::MethodData<bool()>(121, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'startWrite'
        QtMocHelpers::MethodData<void()>(122, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'cancelWrite'
        QtMocHelpers::MethodData<void()>(123, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'skipCacheVerification'
        QtMocHelpers::MethodData<void()>(124, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'skipCurrentVerification'
        QtMocHelpers::MethodData<void()>(125, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'isCached'
        QtMocHelpers::MethodData<bool(const QUrl &, const QByteArray &)>(126, 8, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 68, 45 }, { QMetaType::QByteArray, 117 },
        }}),
        // Method 'getDriveList'
        QtMocHelpers::MethodData<DriveListModel *()>(127, 8, QMC::AccessPublic, 0x80000000 | 128),
        // Method 'getHWList'
        QtMocHelpers::MethodData<HWListModel *()>(129, 8, QMC::AccessPublic, 0x80000000 | 130),
        // Method 'getOSList'
        QtMocHelpers::MethodData<OSListModel *()>(131, 8, QMC::AccessPublic, 0x80000000 | 132),
        // Method 'fileNameFromUrl'
        QtMocHelpers::MethodData<QString(const QUrl &)>(133, 8, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 68, 45 },
        }}),
        // Method 'osListUrlForDisplay'
        QtMocHelpers::MethodData<QString() const>(134, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'osListUrl'
        QtMocHelpers::MethodData<QUrl() const>(135, 8, QMC::AccessPublic, 0x80000000 | 68),
        // Method 'constantVersion'
        QtMocHelpers::MethodData<QString() const>(136, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'isVersionNewer'
        QtMocHelpers::MethodData<bool(const QString &)>(137, 8, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 138 },
        }}),
        // Method 'setCustomOsListUrl'
        QtMocHelpers::MethodData<void(const QUrl &)>(139, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 68, 45 },
        }}),
        // Method 'getFilteredOSlist'
        QtMocHelpers::MethodData<QByteArray()>(140, 8, QMC::AccessPublic, QMetaType::QByteArray),
        // Method 'getFilteredOSlistDocument'
        QtMocHelpers::MethodData<QJsonDocument()>(141, 8, QMC::AccessPublic, 0x80000000 | 142),
        // Method 'beginOSListFetch'
        QtMocHelpers::MethodData<void()>(143, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'setHWFilterList'
        QtMocHelpers::MethodData<void(const QJsonArray &, const bool &)>(144, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 145, 146 }, { QMetaType::Bool, 147 },
        }}),
        // Method 'setHWCapabilitiesList'
        QtMocHelpers::MethodData<void(const QJsonArray &)>(148, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 145, 149 },
        }}),
        // Method 'setSWCapabilitiesList'
        QtMocHelpers::MethodData<void(const QString &)>(150, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 149 },
        }}),
        // Method 'setSWCapabilitiesList'
        QtMocHelpers::MethodData<void(const QVariantList &)>(150, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 151, 152 },
        }}),
        // Method 'getHWFilterList'
        QtMocHelpers::MethodData<QJsonArray()>(153, 8, QMC::AccessPublic, 0x80000000 | 145),
        // Method 'getHWFilterListInclusive'
        QtMocHelpers::MethodData<bool()>(154, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'checkHWAndSWCapability'
        QtMocHelpers::MethodData<bool(const QString &, const QString &)>(155, 8, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 156 }, { QMetaType::QString, 157 },
        }}),
        // Method 'checkHWAndSWCapability'
        QtMocHelpers::MethodData<bool(const QString &)>(155, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 156 },
        }}),
        // Method 'checkHWCapability'
        QtMocHelpers::MethodData<bool(const QString &)>(158, 8, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 156 },
        }}),
        // Method 'checkSWCapability'
        QtMocHelpers::MethodData<bool(const QString &)>(159, 8, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 156 },
        }}),
        // Method 'openFileDialog'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(160, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 161 }, { QMetaType::QString, 162 },
        }}),
        // Method 'nativeFileDialogAvailable'
        QtMocHelpers::MethodData<bool()>(163, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'acceptCustomImageFromQml'
        QtMocHelpers::MethodData<void(const QUrl &)>(164, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 68, 165 },
        }}),
        // Method 'getNativeOpenFileName'
        QtMocHelpers::MethodData<QString(const QString &, const QString &, const QString &)>(166, 8, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 161 }, { QMetaType::QString, 54 }, { QMetaType::QString, 162 },
        }}),
        // Method 'getNativeOpenFileName'
        QtMocHelpers::MethodData<QString(const QString &, const QString &)>(166, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 161 }, { QMetaType::QString, 54 },
        }}),
        // Method 'getNativeOpenFileName'
        QtMocHelpers::MethodData<QString(const QString &)>(166, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::QString, 161 },
        }}),
        // Method 'getNativeOpenFileName'
        QtMocHelpers::MethodData<QString()>(166, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString),
        // Method 'setMainWindow'
        QtMocHelpers::MethodData<void(QObject *)>(167, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QObjectStar, 168 },
        }}),
        // Method 'readFileContents'
        QtMocHelpers::MethodData<QString(const QString &)>(169, 8, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 170 },
        }}),
        // Method 'keychainPermissionResponse'
        QtMocHelpers::MethodData<void(bool)>(171, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 172 },
        }}),
        // Method 'srcFileName'
        QtMocHelpers::MethodData<QString()>(173, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'getSelectedSourceSize'
        QtMocHelpers::MethodData<quint64()>(174, 8, QMC::AccessPublic, QMetaType::ULongLong),
        // Method 'formatSize'
        QtMocHelpers::MethodData<QString(quint64, int)>(175, 8, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::ULongLong, 176 }, { QMetaType::Int, 177 },
        }}),
        // Method 'formatSize'
        QtMocHelpers::MethodData<QString(quint64)>(175, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::QString, {{
            { QMetaType::ULongLong, 176 },
        }}),
        // Method 'isOnline'
        QtMocHelpers::MethodData<bool()>(178, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'isEmbeddedMode'
        QtMocHelpers::MethodData<bool() const>(179, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'hasWindowDecorations'
        QtMocHelpers::MethodData<bool() const>(180, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'mountUsbSourceMedia'
        QtMocHelpers::MethodData<bool()>(181, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'getUsbSourceOSlist'
        QtMocHelpers::MethodData<QByteArray()>(182, 8, QMC::AccessPublic, QMetaType::QByteArray),
        // Method 'getDefaultPubKey'
        QtMocHelpers::MethodData<QString()>(183, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'hasPubKey'
        QtMocHelpers::MethodData<bool()>(184, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'hasSshKeyGen'
        QtMocHelpers::MethodData<bool()>(185, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'generatePubKey'
        QtMocHelpers::MethodData<void()>(186, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'getTimezone'
        QtMocHelpers::MethodData<QString()>(187, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'getTimezoneList'
        QtMocHelpers::MethodData<QStringList()>(188, 8, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'getCountryList'
        QtMocHelpers::MethodData<QStringList()>(189, 8, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'getKeymapLayoutList'
        QtMocHelpers::MethodData<QStringList()>(190, 8, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'getCapitalCitiesList'
        QtMocHelpers::MethodData<QStringList()>(191, 8, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'getLocaleDataForCapital'
        QtMocHelpers::MethodData<QVariantMap(const QString &)>(192, 8, QMC::AccessPublic, 0x80000000 | 193, {{
            { QMetaType::QString, 194 },
        }}),
        // Method 'getSSID'
        QtMocHelpers::MethodData<QString()>(195, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'getPSK'
        QtMocHelpers::MethodData<QString()>(196, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'getPSKForSSID'
        QtMocHelpers::MethodData<QString(const QString &)>(197, 8, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 198 },
        }}),
        // Method 'getBoolSetting'
        QtMocHelpers::MethodData<bool(const QString &)>(199, 8, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 200 },
        }}),
        // Method 'getStringSetting'
        QtMocHelpers::MethodData<QString(const QString &)>(201, 8, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 200 },
        }}),
        // Method 'setSetting'
        QtMocHelpers::MethodData<void(const QString &, const QVariant &)>(202, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 200 }, { 0x80000000 | 9, 203 },
        }}),
        // Method 'getRsaKeyFingerprint'
        QtMocHelpers::MethodData<QString(const QString &)>(204, 8, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 205 },
        }}),
        // Method 'getDebugDirectIO'
        QtMocHelpers::MethodData<bool() const>(206, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'setDebugDirectIO'
        QtMocHelpers::MethodData<void(bool)>(207, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 208 },
        }}),
        // Method 'getDebugPeriodicSync'
        QtMocHelpers::MethodData<bool() const>(209, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'setDebugPeriodicSync'
        QtMocHelpers::MethodData<void(bool)>(210, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 208 },
        }}),
        // Method 'getDebugVerboseLogging'
        QtMocHelpers::MethodData<bool() const>(211, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'setDebugVerboseLogging'
        QtMocHelpers::MethodData<void(bool)>(212, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 208 },
        }}),
        // Method 'getDebugAsyncIO'
        QtMocHelpers::MethodData<bool() const>(213, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'setDebugAsyncIO'
        QtMocHelpers::MethodData<void(bool)>(214, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 208 },
        }}),
        // Method 'getDebugAsyncQueueDepth'
        QtMocHelpers::MethodData<int() const>(215, 8, QMC::AccessPublic, QMetaType::Int),
        // Method 'setDebugAsyncQueueDepth'
        QtMocHelpers::MethodData<void(int)>(216, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 217 },
        }}),
        // Method 'getDebugIPv4Only'
        QtMocHelpers::MethodData<bool() const>(218, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'setDebugIPv4Only'
        QtMocHelpers::MethodData<void(bool)>(219, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 208 },
        }}),
        // Method 'getDebugSkipEndOfDevice'
        QtMocHelpers::MethodData<bool() const>(220, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'setDebugSkipEndOfDevice'
        QtMocHelpers::MethodData<void(bool)>(221, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 208 },
        }}),
        // Method 'getDebugRpiboot'
        QtMocHelpers::MethodData<bool() const>(222, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'setDebugRpiboot'
        QtMocHelpers::MethodData<void(bool)>(223, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 208 },
        }}),
        // Method 'getDebugCustomFastbootGadget'
        QtMocHelpers::MethodData<QString() const>(224, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'setDebugCustomFastbootGadget'
        QtMocHelpers::MethodData<void(const QString &)>(225, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 226 },
        }}),
        // Method 'applyCustomisationFromSettings'
        QtMocHelpers::MethodData<void(const QVariantMap &)>(227, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 193, 228 },
        }}),
        // Method 'setImageCustomisation'
        QtMocHelpers::MethodData<void(const QByteArray &, const QByteArray &, const QByteArray &, const QByteArray &, const QByteArray &, const ImageOptions::AdvancedOptions, const QByteArray &)>(229, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 230 }, { QMetaType::QByteArray, 231 }, { QMetaType::QByteArray, 232 }, { QMetaType::QByteArray, 233 },
            { QMetaType::QByteArray, 234 }, { 0x80000000 | 235, 236 }, { QMetaType::QByteArray, 106 },
        }}),
        // Method 'setImageCustomisation'
        QtMocHelpers::MethodData<void(const QByteArray &, const QByteArray &, const QByteArray &, const QByteArray &, const QByteArray &, const ImageOptions::AdvancedOptions)>(229, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QByteArray, 230 }, { QMetaType::QByteArray, 231 }, { QMetaType::QByteArray, 232 }, { QMetaType::QByteArray, 233 },
            { QMetaType::QByteArray, 234 }, { 0x80000000 | 235, 236 },
        }}),
        // Method 'setImageCustomisation'
        QtMocHelpers::MethodData<void(const QByteArray &, const QByteArray &, const QByteArray &, const QByteArray &, const QByteArray &)>(229, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QByteArray, 230 }, { QMetaType::QByteArray, 231 }, { QMetaType::QByteArray, 232 }, { QMetaType::QByteArray, 233 },
            { QMetaType::QByteArray, 234 },
        }}),
        // Method 'setSavedCustomisationSettings'
        QtMocHelpers::MethodData<void(const QVariantMap &)>(237, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 193, 238 },
        }}),
        // Method 'getSavedCustomisationSettings'
        QtMocHelpers::MethodData<QVariantMap()>(239, 8, QMC::AccessPublic, 0x80000000 | 193),
        // Method 'setPersistedCustomisationSetting'
        QtMocHelpers::MethodData<void(const QString &, const QVariant &)>(240, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 200 }, { 0x80000000 | 9, 203 },
        }}),
        // Method 'removePersistedCustomisationSetting'
        QtMocHelpers::MethodData<void(const QString &)>(241, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 200 },
        }}),
        // Method 'clearSavedCustomisationSettings'
        QtMocHelpers::MethodData<void()>(242, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'imageSupportsCustomization'
        QtMocHelpers::MethodData<bool()>(243, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'imageSupportsCcRpi'
        QtMocHelpers::MethodData<bool()>(244, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'crypt'
        QtMocHelpers::MethodData<QString(const QByteArray &)>(245, 8, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QByteArray, 246 },
        }}),
        // Method 'pbkdf2'
        QtMocHelpers::MethodData<QString(const QByteArray &, const QByteArray &)>(247, 8, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QByteArray, 248 }, { QMetaType::QByteArray, 198 },
        }}),
        // Method 'getTranslations'
        QtMocHelpers::MethodData<QStringList()>(249, 8, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'getCurrentLanguage'
        QtMocHelpers::MethodData<QString()>(250, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'getCurrentKeyboard'
        QtMocHelpers::MethodData<QString()>(251, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'getCurrentUser'
        QtMocHelpers::MethodData<QString()>(252, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'changeLanguage'
        QtMocHelpers::MethodData<void(const QString &)>(253, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 254 },
        }}),
        // Method 'changeKeyboard'
        QtMocHelpers::MethodData<void(const QString &)>(255, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 256 },
        }}),
        // Method 'customRepo'
        QtMocHelpers::MethodData<bool()>(257, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'customRepoHost'
        QtMocHelpers::MethodData<QString()>(258, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'isValidRepoUrl'
        QtMocHelpers::MethodData<bool(const QString &) const>(259, 8, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 45 },
        }}),
        // Method 'isSecureBootForcedByCliFlag'
        QtMocHelpers::MethodData<bool() const>(260, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'hasMouse'
        QtMocHelpers::MethodData<bool()>(261, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'reboot'
        QtMocHelpers::MethodData<void()>(262, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'openUrl'
        QtMocHelpers::MethodData<void(const QUrl &)>(263, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 68, 45 },
        }}),
        // Method 'isScreenReaderActive'
        QtMocHelpers::MethodData<bool() const>(264, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'handleIncomingUrl'
        QtMocHelpers::MethodData<void(const QUrl &)>(265, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 68, 45 },
        }}),
        // Method 'overwriteConnectToken'
        QtMocHelpers::MethodData<void(const QString &)>(266, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 41 },
        }}),
        // Method 'getRuntimeConnectToken'
        QtMocHelpers::MethodData<QString() const>(267, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'verifyAuthKey'
        QtMocHelpers::MethodData<bool(const QString &, bool) const>(268, 8, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 41 }, { QMetaType::Bool, 269 },
        }}),
        // Method 'verifyAuthKey'
        QtMocHelpers::MethodData<bool(const QString &) const>(268, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Bool, {{
            { QMetaType::QString, 41 },
        }}),
        // Method 'clearConnectToken'
        QtMocHelpers::MethodData<void()>(270, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'setOsListRefreshOverride'
        QtMocHelpers::MethodData<void(int, int)>(271, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 272 }, { QMetaType::Int, 273 },
        }}),
        // Method 'refreshOsListFrom'
        QtMocHelpers::MethodData<void(const QUrl &)>(274, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 68, 45 },
        }}),
        // Method 'refreshOsListFromDefaultUrl'
        QtMocHelpers::MethodData<void()>(275, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'isElevatableBundle'
        QtMocHelpers::MethodData<bool()>(276, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'hasElevationPolicyInstalled'
        QtMocHelpers::MethodData<bool()>(277, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'installElevationPolicy'
        QtMocHelpers::MethodData<bool()>(278, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'restartWithElevatedPrivileges'
        QtMocHelpers::MethodData<void()>(279, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'isBeepAvailable'
        QtMocHelpers::MethodData<bool()>(280, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'setRpibootDevice'
        QtMocHelpers::MethodData<void(const QString &)>(281, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 87 },
        }}),
        // Method 'isRpibootDevice'
        QtMocHelpers::MethodData<bool() const>(282, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'setFastbootDevice'
        QtMocHelpers::MethodData<void(const QString &, quint64)>(283, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 81 }, { QMetaType::ULongLong, 284 },
        }}),
        // Method 'exportPerformanceData'
        QtMocHelpers::MethodData<bool()>(285, 8, QMC::AccessPublic, QMetaType::Bool),
        // Method 'exportPerformanceDataToFile'
        QtMocHelpers::MethodData<bool(const QString &)>(286, 8, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 170 },
        }}),
        // Method 'getPerformanceDataFilename'
        QtMocHelpers::MethodData<QString()>(287, 8, QMC::AccessPublic, QMetaType::QString),
        // Method 'hasPerformanceData'
        QtMocHelpers::MethodData<bool()>(288, 8, QMC::AccessPublic, QMetaType::Bool),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'writeState'
        QtMocHelpers::PropertyData<enum WriteState>(289, 0x80000000 | 290, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 21),
        // property 'isOsListUnavailable'
        QtMocHelpers::PropertyData<bool>(291, QMetaType::Bool, QMC::DefaultPropertyFlags, 29),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'WriteState'
        QtMocHelpers::EnumData<enum WriteState>(290, 290, QMC::EnumIsScoped).add({
            {  292, WriteState::Idle },
            {  293, WriteState::Preparing },
            {  294, WriteState::Writing },
            {  295, WriteState::Verifying },
            {  296, WriteState::Finalizing },
            {  297, WriteState::Cancelling },
            {  298, WriteState::Succeeded },
            {  299, WriteState::Failed },
            {  300, WriteState::Cancelled },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<ImageWriter, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject ImageWriter::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11ImageWriterE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11ImageWriterE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11ImageWriterE_t>.metaTypes,
    nullptr
} };

void ImageWriter::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ImageWriter *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->downloadProgress((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 1: _t->writeProgress((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 2: _t->verifyProgress((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 3: _t->error((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 4: _t->success(); break;
        case 5: _t->fileSelected((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 6: _t->cancelled(); break;
        case 7: _t->finalizing(); break;
        case 8: _t->networkOnline(); break;
        case 9: _t->preparationStatusUpdate((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 10: _t->osListPrepared(); break;
        case 11: _t->bottleneckStatusChanged((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 12: _t->operationWarning((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 13: _t->hwFilterChanged(); break;
        case 14: _t->networkInfo((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 15: _t->cacheVerificationStarted(); break;
        case 16: _t->cacheVerificationFinished(); break;
        case 17: _t->selectedDeviceRemoved(); break;
        case 18: _t->writeCancelledDueToDeviceRemoval(); break;
        case 19: _t->keychainPermissionRequested(); break;
        case 20: _t->keychainPermissionResponseReceived(); break;
        case 21: _t->writeStateChanged(); break;
        case 22: _t->connectTokenReceived((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 23: _t->connectTokenConflictDetected((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 24: _t->connectTokenCleared(); break;
        case 25: _t->repositoryUrlReceived((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 26: _t->customRepoChanged(); break;
        case 27: _t->customRepoHostChanged(); break;
        case 28: _t->cacheStatusChanged(); break;
        case 29: _t->osListUnavailableChanged(); break;
        case 30: _t->permissionWarning((*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[1]))); break;
        case 31: _t->locationPermissionGranted(); break;
        case 32: _t->performanceSaveDialogNeeded((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 33: _t->startProgressPolling(); break;
        case 34: _t->stopProgressPolling(); break;
        case 35: _t->pollNetwork(); break;
        case 36: _t->restartWrite((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 37: _t->onSuccess(); break;
        case 38: _t->onError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 39: _t->onFileSelected((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 40: _t->onCancelled(); break;
        case 41: _t->onFinalizing(); break;
        case 42: _t->onPreparationStatusUpdate((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 43: _t->onOsListFetchComplete((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[3]))); break;
        case 44: _t->onOsListFetchError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[2]))); break;
        case 45: _t->onNetworkConnectionStats((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[2]))); break;
        case 46: _t->onSTPdetected(); break;
        case 47: _t->onCacheVerificationProgress((*reinterpret_cast<std::add_pointer_t<qint64>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<qint64>>(_a[2]))); break;
        case 48: _t->onCacheVerificationComplete((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 49: _t->onSelectedDeviceRemoved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 50: _t->onOsListRefreshTimeout(); break;
        case 51: _t->onRpibootFastbootReady((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 52: _t->onRpibootError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 53: _t->onRpibootDeviceDetected((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<uint8_t>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<uint8_t>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QList<uint8_t>>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<uint16_t>>(_a[5]))); break;
        case 54: _t->onBootstrapComplete((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 55: _t->onBootstrapError((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 56: { bool _r = _t->isExtractSizeKnown();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 57: _t->setSrc((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[8])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[9])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[10]))); break;
        case 58: _t->setSrc((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[8])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[9]))); break;
        case 59: _t->setSrc((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[8]))); break;
        case 60: _t->setSrc((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[7]))); break;
        case 61: _t->setSrc((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[6]))); break;
        case 62: _t->setSrc((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5]))); break;
        case 63: _t->setSrc((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[4]))); break;
        case 64: _t->setSrc((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[3]))); break;
        case 65: _t->setSrc((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2]))); break;
        case 66: _t->setSrc((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 67: _t->setDst((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2]))); break;
        case 68: _t->setDst((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 69: _t->setVerifyEnabled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 70: _t->setCustomRepo((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 71: _t->setCustomCacheFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2]))); break;
        case 72: { bool _r = _t->readyToWrite();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 73: { bool _r = _t->isRaspberryPiDevice();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 74: { QString _r = _t->getHardwareName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 75: { bool _r = _t->createHardwareTags();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 76: _t->startWrite(); break;
        case 77: _t->cancelWrite(); break;
        case 78: _t->skipCacheVerification(); break;
        case 79: _t->skipCurrentVerification(); break;
        case 80: { bool _r = _t->isCached((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 81: { DriveListModel* _r = _t->getDriveList();
            if (_a[0]) *reinterpret_cast<DriveListModel**>(_a[0]) = std::move(_r); }  break;
        case 82: { HWListModel* _r = _t->getHWList();
            if (_a[0]) *reinterpret_cast<HWListModel**>(_a[0]) = std::move(_r); }  break;
        case 83: { OSListModel* _r = _t->getOSList();
            if (_a[0]) *reinterpret_cast<OSListModel**>(_a[0]) = std::move(_r); }  break;
        case 84: { QString _r = _t->fileNameFromUrl((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 85: { QString _r = _t->osListUrlForDisplay();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 86: { QUrl _r = _t->osListUrl();
            if (_a[0]) *reinterpret_cast<QUrl*>(_a[0]) = std::move(_r); }  break;
        case 87: { QString _r = _t->constantVersion();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 88: { bool _r = _t->isVersionNewer((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 89: _t->setCustomOsListUrl((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 90: { QByteArray _r = _t->getFilteredOSlist();
            if (_a[0]) *reinterpret_cast<QByteArray*>(_a[0]) = std::move(_r); }  break;
        case 91: { QJsonDocument _r = _t->getFilteredOSlistDocument();
            if (_a[0]) *reinterpret_cast<QJsonDocument*>(_a[0]) = std::move(_r); }  break;
        case 92: _t->beginOSListFetch(); break;
        case 93: _t->setHWFilterList((*reinterpret_cast<std::add_pointer_t<QJsonArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 94: _t->setHWCapabilitiesList((*reinterpret_cast<std::add_pointer_t<QJsonArray>>(_a[1]))); break;
        case 95: _t->setSWCapabilitiesList((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 96: _t->setSWCapabilitiesList((*reinterpret_cast<std::add_pointer_t<QVariantList>>(_a[1]))); break;
        case 97: { QJsonArray _r = _t->getHWFilterList();
            if (_a[0]) *reinterpret_cast<QJsonArray*>(_a[0]) = std::move(_r); }  break;
        case 98: { bool _r = _t->getHWFilterListInclusive();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 99: { bool _r = _t->checkHWAndSWCapability((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 100: { bool _r = _t->checkHWAndSWCapability((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 101: { bool _r = _t->checkHWCapability((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 102: { bool _r = _t->checkSWCapability((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 103: _t->openFileDialog((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 104: { bool _r = _t->nativeFileDialogAvailable();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 105: _t->acceptCustomImageFromQml((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 106: { QString _r = _t->getNativeOpenFileName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 107: { QString _r = _t->getNativeOpenFileName((*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;
        case 108: { QString _r = _t->getNativeOpenFileName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 109: { QString _r = _t->getNativeOpenFileName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 110: _t->setMainWindow((*reinterpret_cast<std::add_pointer_t<QObject*>>(_a[1]))); break;
        case 111: { QString _r = _t->readFileContents((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 112: _t->keychainPermissionResponse((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 113: { QString _r = _t->srcFileName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 114: { quint64 _r = _t->getSelectedSourceSize();
            if (_a[0]) *reinterpret_cast<quint64*>(_a[0]) = std::move(_r); }  break;
        case 115: { QString _r = _t->formatSize((*reinterpret_cast<std::add_pointer_t<quint64>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 116: { QString _r = _t->formatSize((*reinterpret_cast<std::add_pointer_t<quint64>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 117: { bool _r = _t->isOnline();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 118: { bool _r = _t->isEmbeddedMode();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 119: { bool _r = _t->hasWindowDecorations();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 120: { bool _r = _t->mountUsbSourceMedia();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 121: { QByteArray _r = _t->getUsbSourceOSlist();
            if (_a[0]) *reinterpret_cast<QByteArray*>(_a[0]) = std::move(_r); }  break;
        case 122: { QString _r = _t->getDefaultPubKey();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 123: { bool _r = _t->hasPubKey();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 124: { bool _r = _t->hasSshKeyGen();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 125: _t->generatePubKey(); break;
        case 126: { QString _r = _t->getTimezone();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 127: { QStringList _r = _t->getTimezoneList();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 128: { QStringList _r = _t->getCountryList();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 129: { QStringList _r = _t->getKeymapLayoutList();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 130: { QStringList _r = _t->getCapitalCitiesList();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 131: { QVariantMap _r = _t->getLocaleDataForCapital((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVariantMap*>(_a[0]) = std::move(_r); }  break;
        case 132: { QString _r = _t->getSSID();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 133: { QString _r = _t->getPSK();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 134: { QString _r = _t->getPSKForSSID((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 135: { bool _r = _t->getBoolSetting((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 136: { QString _r = _t->getStringSetting((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 137: _t->setSetting((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 138: { QString _r = _t->getRsaKeyFingerprint((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 139: { bool _r = _t->getDebugDirectIO();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 140: _t->setDebugDirectIO((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 141: { bool _r = _t->getDebugPeriodicSync();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 142: _t->setDebugPeriodicSync((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 143: { bool _r = _t->getDebugVerboseLogging();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 144: _t->setDebugVerboseLogging((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 145: { bool _r = _t->getDebugAsyncIO();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 146: _t->setDebugAsyncIO((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 147: { int _r = _t->getDebugAsyncQueueDepth();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 148: _t->setDebugAsyncQueueDepth((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 149: { bool _r = _t->getDebugIPv4Only();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 150: _t->setDebugIPv4Only((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 151: { bool _r = _t->getDebugSkipEndOfDevice();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 152: _t->setDebugSkipEndOfDevice((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 153: { bool _r = _t->getDebugRpiboot();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 154: _t->setDebugRpiboot((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 155: { QString _r = _t->getDebugCustomFastbootGadget();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 156: _t->setDebugCustomFastbootGadget((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 157: _t->applyCustomisationFromSettings((*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[1]))); break;
        case 158: _t->setImageCustomisation((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<ImageOptions::AdvancedOptions>>(_a[6])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[7]))); break;
        case 159: _t->setImageCustomisation((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[5])),(*reinterpret_cast<std::add_pointer_t<ImageOptions::AdvancedOptions>>(_a[6]))); break;
        case 160: _t->setImageCustomisation((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[5]))); break;
        case 161: _t->setSavedCustomisationSettings((*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[1]))); break;
        case 162: { QVariantMap _r = _t->getSavedCustomisationSettings();
            if (_a[0]) *reinterpret_cast<QVariantMap*>(_a[0]) = std::move(_r); }  break;
        case 163: _t->setPersistedCustomisationSetting((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QVariant>>(_a[2]))); break;
        case 164: _t->removePersistedCustomisationSetting((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 165: _t->clearSavedCustomisationSettings(); break;
        case 166: { bool _r = _t->imageSupportsCustomization();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 167: { bool _r = _t->imageSupportsCcRpi();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 168: { QString _r = _t->crypt((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 169: { QString _r = _t->pbkdf2((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 170: { QStringList _r = _t->getTranslations();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 171: { QString _r = _t->getCurrentLanguage();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 172: { QString _r = _t->getCurrentKeyboard();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 173: { QString _r = _t->getCurrentUser();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 174: _t->changeLanguage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 175: _t->changeKeyboard((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 176: { bool _r = _t->customRepo();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 177: { QString _r = _t->customRepoHost();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 178: { bool _r = _t->isValidRepoUrl((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 179: { bool _r = _t->isSecureBootForcedByCliFlag();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 180: { bool _r = _t->hasMouse();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 181: _t->reboot(); break;
        case 182: _t->openUrl((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 183: { bool _r = _t->isScreenReaderActive();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 184: _t->handleIncomingUrl((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 185: _t->overwriteConnectToken((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 186: { QString _r = _t->getRuntimeConnectToken();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 187: { bool _r = _t->verifyAuthKey((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 188: { bool _r = _t->verifyAuthKey((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 189: _t->clearConnectToken(); break;
        case 190: _t->setOsListRefreshOverride((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 191: _t->refreshOsListFrom((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 192: _t->refreshOsListFromDefaultUrl(); break;
        case 193: { bool _r = _t->isElevatableBundle();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 194: { bool _r = _t->hasElevationPolicyInstalled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 195: { bool _r = _t->installElevationPolicy();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 196: _t->restartWithElevatedPrivileges(); break;
        case 197: { bool _r = _t->isBeepAvailable();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 198: _t->setRpibootDevice((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 199: { bool _r = _t->isRpibootDevice();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 200: _t->setFastbootDevice((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint64>>(_a[2]))); break;
        case 201: { bool _r = _t->exportPerformanceData();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 202: { bool _r = _t->exportPerformanceDataToFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 203: { QString _r = _t->getPerformanceDataFilename();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 204: { bool _r = _t->hasPerformanceData();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(QVariant , QVariant )>(_a, &ImageWriter::downloadProgress, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(QVariant , QVariant )>(_a, &ImageWriter::writeProgress, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(QVariant , QVariant )>(_a, &ImageWriter::verifyProgress, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(QVariant )>(_a, &ImageWriter::error, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::success, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(QVariant )>(_a, &ImageWriter::fileSelected, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::cancelled, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::finalizing, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::networkOnline, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(QVariant )>(_a, &ImageWriter::preparationStatusUpdate, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::osListPrepared, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(QVariant , QVariant )>(_a, &ImageWriter::bottleneckStatusChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(QVariant )>(_a, &ImageWriter::operationWarning, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::hwFilterChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(QVariant )>(_a, &ImageWriter::networkInfo, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::cacheVerificationStarted, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::cacheVerificationFinished, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::selectedDeviceRemoved, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::writeCancelledDueToDeviceRemoval, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::keychainPermissionRequested, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::keychainPermissionResponseReceived, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::writeStateChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(const QString & )>(_a, &ImageWriter::connectTokenReceived, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(const QString & )>(_a, &ImageWriter::connectTokenConflictDetected, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::connectTokenCleared, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(const QString & )>(_a, &ImageWriter::repositoryUrlReceived, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::customRepoChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::customRepoHostChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::cacheStatusChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::osListUnavailableChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(QVariant )>(_a, &ImageWriter::permissionWarning, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)()>(_a, &ImageWriter::locationPermissionGranted, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (ImageWriter::*)(const QString & , const QString & )>(_a, &ImageWriter::performanceSaveDialogNeeded, 32))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<enum WriteState*>(_v) = _t->writeState(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->isOsListUnavailable(); break;
        default: break;
        }
    }
}

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

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

int ImageWriter::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 < 205)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 205;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 205)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 205;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    return _id;
}

// SIGNAL 0
void ImageWriter::downloadProgress(QVariant _t1, QVariant _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void ImageWriter::writeProgress(QVariant _t1, QVariant _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2);
}

// SIGNAL 2
void ImageWriter::verifyProgress(QVariant _t1, QVariant _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1, _t2);
}

// SIGNAL 3
void ImageWriter::error(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void ImageWriter::success()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void ImageWriter::fileSelected(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void ImageWriter::cancelled()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void ImageWriter::finalizing()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void ImageWriter::networkOnline()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void ImageWriter::preparationStatusUpdate(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void ImageWriter::osListPrepared()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void ImageWriter::bottleneckStatusChanged(QVariant _t1, QVariant _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1, _t2);
}

// SIGNAL 12
void ImageWriter::operationWarning(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void ImageWriter::hwFilterChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void ImageWriter::networkInfo(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void ImageWriter::cacheVerificationStarted()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void ImageWriter::cacheVerificationFinished()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

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

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

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

// SIGNAL 20
void ImageWriter::keychainPermissionResponseReceived()
{
    QMetaObject::activate(this, &staticMetaObject, 20, nullptr);
}

// SIGNAL 21
void ImageWriter::writeStateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 21, nullptr);
}

// SIGNAL 22
void ImageWriter::connectTokenReceived(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void ImageWriter::connectTokenConflictDetected(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void ImageWriter::connectTokenCleared()
{
    QMetaObject::activate(this, &staticMetaObject, 24, nullptr);
}

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

// SIGNAL 26
void ImageWriter::customRepoChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 26, nullptr);
}

// SIGNAL 27
void ImageWriter::customRepoHostChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 27, nullptr);
}

// SIGNAL 28
void ImageWriter::cacheStatusChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 28, nullptr);
}

// SIGNAL 29
void ImageWriter::osListUnavailableChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 29, nullptr);
}

// SIGNAL 30
void ImageWriter::permissionWarning(QVariant _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1);
}

// SIGNAL 31
void ImageWriter::locationPermissionGranted()
{
    QMetaObject::activate(this, &staticMetaObject, 31, nullptr);
}

// SIGNAL 32
void ImageWriter::performanceSaveDialogNeeded(const QString & _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 32, nullptr, _t1, _t2);
}
QT_WARNING_POP
