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

#include "../../../../../MediaWriter/src/app/releasemanager.h"
#include <QtNetwork/QSslError>
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'releasemanager.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.2. 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_ZN14ReleaseManagerE_t {};
} // unnamed namespace

template <> constexpr inline auto ReleaseManager::qt_create_metaobjectdata<qt_meta_tag_ZN14ReleaseManagerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ReleaseManager",
        "beingUpdatedChanged",
        "",
        "frontPageChanged",
        "filterTextChanged",
        "filterArchitectureChanged",
        "filterSourceChanged",
        "selectedChanged",
        "firstSourceChanged",
        "variantChanged",
        "localFileChanged",
        "fetchReleases",
        "variantChangedFilter",
        "get",
        "Release*",
        "index",
        "selectLocalFile",
        "path",
        "frontPage",
        "beingUpdated",
        "filterArchitecture",
        "filterSource",
        "filterText",
        "selected",
        "selectedIndex",
        "variant",
        "ReleaseVariant*",
        "architectures",
        "localFile",
        "firstSource"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'beingUpdatedChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'frontPageChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'filterTextChanged'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'filterArchitectureChanged'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'filterSourceChanged'
        QtMocHelpers::SignalData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'selectedChanged'
        QtMocHelpers::SignalData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'firstSourceChanged'
        QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'variantChanged'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'localFileChanged'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'fetchReleases'
        QtMocHelpers::SlotData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'variantChangedFilter'
        QtMocHelpers::SlotData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'get'
        QtMocHelpers::MethodData<Release *(int) const>(13, 2, QMC::AccessPublic, 0x80000000 | 14, {{
            { QMetaType::Int, 15 },
        }}),
        // Method 'selectLocalFile'
        QtMocHelpers::MethodData<void(const QString &)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 17 },
        }}),
        // Method 'selectLocalFile'
        QtMocHelpers::MethodData<void()>(16, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'frontPage'
        QtMocHelpers::PropertyData<bool>(18, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'beingUpdated'
        QtMocHelpers::PropertyData<bool>(19, QMetaType::Bool, QMC::DefaultPropertyFlags, 0),
        // property 'filterArchitecture'
        QtMocHelpers::PropertyData<int>(20, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'filterSource'
        QtMocHelpers::PropertyData<int>(21, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'filterText'
        QtMocHelpers::PropertyData<QString>(22, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'selected'
        QtMocHelpers::PropertyData<Release*>(23, 0x80000000 | 14, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 5),
        // property 'selectedIndex'
        QtMocHelpers::PropertyData<int>(24, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'variant'
        QtMocHelpers::PropertyData<ReleaseVariant*>(25, 0x80000000 | 26, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 7),
        // property 'architectures'
        QtMocHelpers::PropertyData<QStringList>(27, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'localFile'
        QtMocHelpers::PropertyData<ReleaseVariant*>(28, 0x80000000 | 26, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 8),
        // property 'firstSource'
        QtMocHelpers::PropertyData<int>(29, QMetaType::Int, QMC::DefaultPropertyFlags, 6),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ReleaseManager, qt_meta_tag_ZN14ReleaseManagerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ReleaseManager::staticMetaObject = { {
    QMetaObject::SuperData::link<QSortFilterProxyModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ReleaseManagerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ReleaseManagerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14ReleaseManagerE_t>.metaTypes,
    nullptr
} };

void ReleaseManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ReleaseManager *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->beingUpdatedChanged(); break;
        case 1: _t->frontPageChanged(); break;
        case 2: _t->filterTextChanged(); break;
        case 3: _t->filterArchitectureChanged(); break;
        case 4: _t->filterSourceChanged(); break;
        case 5: _t->selectedChanged(); break;
        case 6: _t->firstSourceChanged(); break;
        case 7: _t->variantChanged(); break;
        case 8: _t->localFileChanged(); break;
        case 9: _t->fetchReleases(); break;
        case 10: _t->variantChangedFilter(); break;
        case 11: { Release* _r = _t->get((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<Release**>(_a[0]) = std::move(_r); }  break;
        case 12: _t->selectLocalFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 13: _t->selectLocalFile(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ReleaseManager::*)()>(_a, &ReleaseManager::beingUpdatedChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseManager::*)()>(_a, &ReleaseManager::frontPageChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseManager::*)()>(_a, &ReleaseManager::filterTextChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseManager::*)()>(_a, &ReleaseManager::filterArchitectureChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseManager::*)()>(_a, &ReleaseManager::filterSourceChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseManager::*)()>(_a, &ReleaseManager::selectedChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseManager::*)()>(_a, &ReleaseManager::firstSourceChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseManager::*)()>(_a, &ReleaseManager::variantChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseManager::*)()>(_a, &ReleaseManager::localFileChanged, 8))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 5:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Release* >(); break;
        case 9:
        case 7:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< ReleaseVariant* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->frontPage(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->beingUpdated(); break;
        case 2: *reinterpret_cast<int*>(_v) = _t->filterArchitecture(); break;
        case 3: *reinterpret_cast<int*>(_v) = _t->filterSource(); break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->filterText(); break;
        case 5: *reinterpret_cast<Release**>(_v) = _t->selected(); break;
        case 6: *reinterpret_cast<int*>(_v) = _t->selectedIndex(); break;
        case 7: *reinterpret_cast<ReleaseVariant**>(_v) = _t->variant(); break;
        case 8: *reinterpret_cast<QStringList*>(_v) = _t->architectures(); break;
        case 9: *reinterpret_cast<ReleaseVariant**>(_v) = _t->localFile(); break;
        case 10: *reinterpret_cast<int*>(_v) = _t->firstSource(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setFrontPage(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->setFilterArchitecture(*reinterpret_cast<int*>(_v)); break;
        case 3: _t->setFilterSource(*reinterpret_cast<int*>(_v)); break;
        case 4: _t->setFilterText(*reinterpret_cast<QString*>(_v)); break;
        case 6: _t->setSelectedIndex(*reinterpret_cast<int*>(_v)); break;
        default: break;
        }
    }
}

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

void *ReleaseManager::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ReleaseManagerE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "DownloadReceiver"))
        return static_cast< DownloadReceiver*>(this);
    return QSortFilterProxyModel::qt_metacast(_clname);
}

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

// SIGNAL 0
void ReleaseManager::beingUpdatedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void ReleaseManager::frontPageChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void ReleaseManager::filterTextChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void ReleaseManager::filterArchitectureChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

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

// SIGNAL 5
void ReleaseManager::selectedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

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

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

// SIGNAL 8
void ReleaseManager::localFileChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}
namespace {
struct qt_meta_tag_ZN16ReleaseListModelE_t {};
} // unnamed namespace

template <> constexpr inline auto ReleaseListModel::qt_create_metaobjectdata<qt_meta_tag_ZN16ReleaseListModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ReleaseListModel",
        "get",
        "Release*",
        "",
        "index",
        "ItemRole",
        "ReleaseRole",
        "SourceIndexRole"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'get'
        QtMocHelpers::MethodData<Release *(int)>(1, 3, QMC::AccessPublic, 0x80000000 | 2, {{
            { QMetaType::Int, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'ItemRole'
        QtMocHelpers::EnumData<enum ItemRole>(5, 5, QMC::EnumFlags{}).add({
            {    6, ItemRole::ReleaseRole },
            {    7, ItemRole::SourceIndexRole },
        }),
    };
    return QtMocHelpers::metaObjectData<ReleaseListModel, qt_meta_tag_ZN16ReleaseListModelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ReleaseListModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractListModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16ReleaseListModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16ReleaseListModelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16ReleaseListModelE_t>.metaTypes,
    nullptr
} };

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

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

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

int ReleaseListModel::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QAbstractListModel::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN7ReleaseE_t {};
} // unnamed namespace

template <> constexpr inline auto Release::qt_create_metaobjectdata<qt_meta_tag_ZN7ReleaseE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Release",
        "versionsChanged",
        "",
        "selectedVersionChanged",
        "prereleaseChanged",
        "sourceString",
        "index",
        "name",
        "summary",
        "description",
        "source",
        "Source",
        "isLocal",
        "category",
        "icon",
        "screenshots",
        "prerelease",
        "versions",
        "QQmlListProperty<ReleaseVersion>",
        "versionNames",
        "version",
        "ReleaseVersion*",
        "versionIndex",
        "PRODUCT",
        "LOCAL",
        "SPINS",
        "LABS",
        "EMERGING",
        "OTHER"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'versionsChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'selectedVersionChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'prereleaseChanged'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'sourceString'
        QtMocHelpers::MethodData<QString()>(5, 2, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'index'
        QtMocHelpers::PropertyData<int>(6, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'name'
        QtMocHelpers::PropertyData<QString>(7, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'summary'
        QtMocHelpers::PropertyData<QString>(8, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'description'
        QtMocHelpers::PropertyData<QString>(9, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'source'
        QtMocHelpers::PropertyData<enum Source>(10, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'isLocal'
        QtMocHelpers::PropertyData<bool>(12, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'category'
        QtMocHelpers::PropertyData<QString>(13, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'icon'
        QtMocHelpers::PropertyData<QString>(14, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'screenshots'
        QtMocHelpers::PropertyData<QStringList>(15, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'prerelease'
        QtMocHelpers::PropertyData<QString>(16, QMetaType::QString, QMC::DefaultPropertyFlags, 2),
        // property 'versions'
        QtMocHelpers::PropertyData<QQmlListProperty<ReleaseVersion>>(17, 0x80000000 | 18, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
        // property 'versionNames'
        QtMocHelpers::PropertyData<QStringList>(19, QMetaType::QStringList, QMC::DefaultPropertyFlags, 0),
        // property 'version'
        QtMocHelpers::PropertyData<ReleaseVersion*>(20, 0x80000000 | 21, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
        // property 'versionIndex'
        QtMocHelpers::PropertyData<int>(22, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable, 1),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Source'
        QtMocHelpers::EnumData<enum Source>(11, 11, QMC::EnumFlags{}).add({
            {   23, Source::PRODUCT },
            {   24, Source::LOCAL },
            {   25, Source::SPINS },
            {   26, Source::LABS },
            {   27, Source::EMERGING },
            {   28, Source::OTHER },
        }),
    };
    return QtMocHelpers::metaObjectData<Release, qt_meta_tag_ZN7ReleaseE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Release::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7ReleaseE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7ReleaseE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7ReleaseE_t>.metaTypes,
    nullptr
} };

void Release::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Release *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->versionsChanged(); break;
        case 1: _t->selectedVersionChanged(); break;
        case 2: _t->prereleaseChanged(); break;
        case 3: { QString _r = _t->sourceString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Release::*)()>(_a, &Release::versionsChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Release::*)()>(_a, &Release::selectedVersionChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Release::*)()>(_a, &Release::prereleaseChanged, 2))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 12:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< ReleaseVersion* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->index(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->name(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->summary(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->description(); break;
        case 4: *reinterpret_cast<enum Source*>(_v) = _t->source(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->isLocal(); break;
        case 6: *reinterpret_cast<QString*>(_v) = _t->sourceString(); break;
        case 7: *reinterpret_cast<QString*>(_v) = _t->icon(); break;
        case 8: *reinterpret_cast<QStringList*>(_v) = _t->screenshots(); break;
        case 9: *reinterpret_cast<QString*>(_v) = _t->prerelease(); break;
        case 10: *reinterpret_cast<QQmlListProperty<ReleaseVersion>*>(_v) = _t->versions(); break;
        case 11: *reinterpret_cast<QStringList*>(_v) = _t->versionNames(); break;
        case 12: *reinterpret_cast<ReleaseVersion**>(_v) = _t->selectedVersion(); break;
        case 13: *reinterpret_cast<int*>(_v) = _t->selectedVersionIndex(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 13: _t->setSelectedVersionIndex(*reinterpret_cast<int*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

// SIGNAL 0
void Release::versionsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void Release::selectedVersionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void Release::prereleaseChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}
namespace {
struct qt_meta_tag_ZN14ReleaseVersionE_t {};
} // unnamed namespace

template <> constexpr inline auto ReleaseVersion::qt_create_metaobjectdata<qt_meta_tag_ZN14ReleaseVersionE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ReleaseVersion",
        "variantsChanged",
        "",
        "selectedVariantChanged",
        "statusChanged",
        "releaseDateChanged",
        "number",
        "name",
        "status",
        "ReleaseVersion::Status",
        "releaseDate",
        "variants",
        "QQmlListProperty<ReleaseVariant>",
        "variant",
        "ReleaseVariant*",
        "variantIndex",
        "Status",
        "FINAL",
        "RELEASE_CANDIDATE",
        "BETA",
        "ALPHA"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'variantsChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'selectedVariantChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'statusChanged'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'releaseDateChanged'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'number'
        QtMocHelpers::PropertyData<int>(6, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'name'
        QtMocHelpers::PropertyData<QString>(7, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'status'
        QtMocHelpers::PropertyData<ReleaseVersion::Status>(8, 0x80000000 | 9, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 2),
        // property 'releaseDate'
        QtMocHelpers::PropertyData<QDateTime>(10, QMetaType::QDateTime, QMC::DefaultPropertyFlags, 3),
        // property 'variants'
        QtMocHelpers::PropertyData<QQmlListProperty<ReleaseVariant>>(11, 0x80000000 | 12, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
        // property 'variant'
        QtMocHelpers::PropertyData<ReleaseVariant*>(13, 0x80000000 | 14, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
        // property 'variantIndex'
        QtMocHelpers::PropertyData<int>(15, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable, 1),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Status'
        QtMocHelpers::EnumData<enum Status>(16, 16, QMC::EnumFlags{}).add({
            {   17, Status::FINAL },
            {   18, Status::RELEASE_CANDIDATE },
            {   19, Status::BETA },
            {   20, Status::ALPHA },
        }),
    };
    return QtMocHelpers::metaObjectData<ReleaseVersion, qt_meta_tag_ZN14ReleaseVersionE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ReleaseVersion::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ReleaseVersionE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ReleaseVersionE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14ReleaseVersionE_t>.metaTypes,
    nullptr
} };

void ReleaseVersion::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ReleaseVersion *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->variantsChanged(); break;
        case 1: _t->selectedVariantChanged(); break;
        case 2: _t->statusChanged(); break;
        case 3: _t->releaseDateChanged(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ReleaseVersion::*)()>(_a, &ReleaseVersion::variantsChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseVersion::*)()>(_a, &ReleaseVersion::selectedVariantChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseVersion::*)()>(_a, &ReleaseVersion::statusChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseVersion::*)()>(_a, &ReleaseVersion::releaseDateChanged, 3))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 5:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< ReleaseVariant* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->number(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->name(); break;
        case 2: *reinterpret_cast<ReleaseVersion::Status*>(_v) = _t->status(); break;
        case 3: *reinterpret_cast<QDateTime*>(_v) = _t->releaseDate(); break;
        case 4: *reinterpret_cast<QQmlListProperty<ReleaseVariant>*>(_v) = _t->variants(); break;
        case 5: *reinterpret_cast<ReleaseVariant**>(_v) = _t->selectedVariant(); break;
        case 6: *reinterpret_cast<int*>(_v) = _t->selectedVariantIndex(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 6: _t->setSelectedVariantIndex(*reinterpret_cast<int*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

// SIGNAL 0
void ReleaseVersion::variantsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void ReleaseVersion::selectedVariantChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void ReleaseVersion::statusChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void ReleaseVersion::releaseDateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}
namespace {
struct qt_meta_tag_ZN14ReleaseVariantE_t {};
} // unnamed namespace

template <> constexpr inline auto ReleaseVariant::qt_create_metaobjectdata<qt_meta_tag_ZN14ReleaseVariantE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ReleaseVariant",
        "isoChanged",
        "",
        "statusChanged",
        "errorStringChanged",
        "urlChanged",
        "sizeChanged",
        "realSizeChanged",
        "shaHashChanged",
        "download",
        "resetStatus",
        "erase",
        "arch",
        "ReleaseArchitecture*",
        "type",
        "ReleaseVariant::Type",
        "name",
        "url",
        "shaHash",
        "iso",
        "size",
        "realSize",
        "progress",
        "Progress*",
        "status",
        "Status",
        "statusString",
        "errorString",
        "Type",
        "LIVE",
        "NETINSTALL",
        "FULL",
        "ATOMIC",
        "PREPARING",
        "DOWNLOADING",
        "DOWNLOAD_VERIFYING",
        "READY",
        "WRITING_NOT_POSSIBLE",
        "WRITING",
        "WRITE_VERIFYING",
        "FINISHED",
        "FAILED_VERIFICATION",
        "FAILED_DOWNLOAD",
        "FAILED"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'isoChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'statusChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'errorStringChanged'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'urlChanged'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sizeChanged'
        QtMocHelpers::SignalData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'realSizeChanged'
        QtMocHelpers::SignalData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'shaHashChanged'
        QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'download'
        QtMocHelpers::SlotData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'resetStatus'
        QtMocHelpers::SlotData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'erase'
        QtMocHelpers::MethodData<bool()>(11, 2, QMC::AccessPublic, QMetaType::Bool),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'arch'
        QtMocHelpers::PropertyData<ReleaseArchitecture*>(12, 0x80000000 | 13, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'type'
        QtMocHelpers::PropertyData<ReleaseVariant::Type>(14, 0x80000000 | 15, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'name'
        QtMocHelpers::PropertyData<QString>(16, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'url'
        QtMocHelpers::PropertyData<QString>(17, QMetaType::QString, QMC::DefaultPropertyFlags, 3),
        // property 'shaHash'
        QtMocHelpers::PropertyData<QString>(18, QMetaType::QString, QMC::DefaultPropertyFlags, 6),
        // property 'iso'
        QtMocHelpers::PropertyData<QString>(19, QMetaType::QString, QMC::DefaultPropertyFlags, 0),
        // property 'size'
        QtMocHelpers::PropertyData<qreal>(20, QMetaType::QReal, QMC::DefaultPropertyFlags, 4),
        // property 'realSize'
        QtMocHelpers::PropertyData<qreal>(21, QMetaType::QReal, QMC::DefaultPropertyFlags, 5),
        // property 'progress'
        QtMocHelpers::PropertyData<Progress*>(22, 0x80000000 | 23, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'status'
        QtMocHelpers::PropertyData<enum Status>(24, 0x80000000 | 25, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
        // property 'statusString'
        QtMocHelpers::PropertyData<QString>(26, QMetaType::QString, QMC::DefaultPropertyFlags, 1),
        // property 'errorString'
        QtMocHelpers::PropertyData<QString>(27, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Type'
        QtMocHelpers::EnumData<enum Type>(28, 28, QMC::EnumFlags{}).add({
            {   29, Type::LIVE },
            {   30, Type::NETINSTALL },
            {   31, Type::FULL },
            {   32, Type::ATOMIC },
        }),
        // enum 'Status'
        QtMocHelpers::EnumData<enum Status>(25, 25, QMC::EnumFlags{}).add({
            {   33, Status::PREPARING },
            {   34, Status::DOWNLOADING },
            {   35, Status::DOWNLOAD_VERIFYING },
            {   36, Status::READY },
            {   37, Status::WRITING_NOT_POSSIBLE },
            {   38, Status::WRITING },
            {   39, Status::WRITE_VERIFYING },
            {   40, Status::FINISHED },
            {   41, Status::FAILED_VERIFICATION },
            {   42, Status::FAILED_DOWNLOAD },
            {   43, Status::FAILED },
        }),
    };
    return QtMocHelpers::metaObjectData<ReleaseVariant, qt_meta_tag_ZN14ReleaseVariantE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ReleaseVariant::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ReleaseVariantE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN14ReleaseVariantE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN14ReleaseVariantE_t>.metaTypes,
    nullptr
} };

void ReleaseVariant::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ReleaseVariant *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->isoChanged(); break;
        case 1: _t->statusChanged(); break;
        case 2: _t->errorStringChanged(); break;
        case 3: _t->urlChanged(); break;
        case 4: _t->sizeChanged(); break;
        case 5: _t->realSizeChanged(); break;
        case 6: _t->shaHashChanged(); break;
        case 7: _t->download(); break;
        case 8: _t->resetStatus(); break;
        case 9: { bool _r = _t->erase();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ReleaseVariant::*)()>(_a, &ReleaseVariant::isoChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseVariant::*)()>(_a, &ReleaseVariant::statusChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseVariant::*)()>(_a, &ReleaseVariant::errorStringChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseVariant::*)()>(_a, &ReleaseVariant::urlChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseVariant::*)()>(_a, &ReleaseVariant::sizeChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseVariant::*)()>(_a, &ReleaseVariant::realSizeChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (ReleaseVariant::*)()>(_a, &ReleaseVariant::shaHashChanged, 6))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 8:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Progress* >(); break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< ReleaseArchitecture* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<ReleaseArchitecture**>(_v) = _t->arch(); break;
        case 1: *reinterpret_cast<ReleaseVariant::Type*>(_v) = _t->type(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->name(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->url(); break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->shaHash(); break;
        case 5: *reinterpret_cast<QString*>(_v) = _t->iso(); break;
        case 6: *reinterpret_cast<qreal*>(_v) = _t->size(); break;
        case 7: *reinterpret_cast<qreal*>(_v) = _t->realSize(); break;
        case 8: *reinterpret_cast<Progress**>(_v) = _t->progress(); break;
        case 9: *reinterpret_cast<enum Status*>(_v) = _t->status(); break;
        case 10: *reinterpret_cast<QString*>(_v) = _t->statusString(); break;
        case 11: *reinterpret_cast<QString*>(_v) = _t->errorString(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 11: _t->setErrorString(*reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

// SIGNAL 0
void ReleaseVariant::isoChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void ReleaseVariant::statusChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void ReleaseVariant::errorStringChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void ReleaseVariant::urlChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

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

// SIGNAL 5
void ReleaseVariant::realSizeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void ReleaseVariant::shaHashChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}
namespace {
struct qt_meta_tag_ZN19ReleaseArchitectureE_t {};
} // unnamed namespace

template <> constexpr inline auto ReleaseArchitecture::qt_create_metaobjectdata<qt_meta_tag_ZN19ReleaseArchitectureE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ReleaseArchitecture",
        "abbreviation",
        "description",
        "details",
        "id",
        "Id",
        "X86_64",
        "X86",
        "ARM",
        "AARCH64",
        "_ARCHCOUNT"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'abbreviation'
        QtMocHelpers::PropertyData<QStringList>(1, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'description'
        QtMocHelpers::PropertyData<QString>(2, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'details'
        QtMocHelpers::PropertyData<QString>(3, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'id'
        QtMocHelpers::PropertyData<enum Id>(4, 0x80000000 | 5, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Id'
        QtMocHelpers::EnumData<enum Id>(5, 5, QMC::EnumFlags{}).add({
            {    6, Id::X86_64 },
            {    7, Id::X86 },
            {    8, Id::ARM },
            {    9, Id::AARCH64 },
            {   10, Id::_ARCHCOUNT },
        }),
    };
    return QtMocHelpers::metaObjectData<ReleaseArchitecture, qt_meta_tag_ZN19ReleaseArchitectureE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ReleaseArchitecture::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19ReleaseArchitectureE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19ReleaseArchitectureE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19ReleaseArchitectureE_t>.metaTypes,
    nullptr
} };

void ReleaseArchitecture::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ReleaseArchitecture *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QStringList*>(_v) = _t->abbreviation(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->description(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->details(); break;
        case 3: *reinterpret_cast<enum Id*>(_v) = _t->id(); break;
        default: break;
        }
    }
}

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

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

int ReleaseArchitecture::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    }
    return _id;
}
QT_WARNING_POP
