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

#include "../../../snapd-qt/Snapd/enums.h"
#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 'enums.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

QT_WARNING_PUSH
QT_WARNING_DISABLE_DEPRECATED
QT_WARNING_DISABLE_GCC("-Wuseless-cast")
namespace {
struct qt_meta_tag_ZN11QSnapdEnumsE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdEnums::qt_create_metaobjectdata<qt_meta_tag_ZN11QSnapdEnumsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdEnums",
        "AliasStatus",
        "AliasStatusUnknown",
        "AliasStatusDefault",
        "AliasStatusEnabled",
        "AliasStatusDisabled",
        "AliasStatusAuto",
        "AliasStatusManual",
        "DaemonType",
        "DaemonTypeNone",
        "DaemonTypeUnknown",
        "DaemonTypeSimple",
        "DaemonTypeForking",
        "DaemonTypeOneshot",
        "DaemonTypeDbus",
        "DaemonTypeNotify",
        "SnapConfinement",
        "SnapConfinementUnknown",
        "SnapConfinementStrict",
        "SnapConfinementDevmode",
        "SnapConfinementClassic",
        "SnapType",
        "SnapTypeUnknown",
        "SnapTypeApp",
        "SnapTypeKernel",
        "SnapTypeGadget",
        "SnapTypeOperatingSystem",
        "SnapTypeCore",
        "SnapTypeBase",
        "SnapTypeSnapd",
        "SnapStatus",
        "SnapStatusUnknown",
        "SnapStatusAvailable",
        "SnapStatusPriced",
        "SnapStatusInstalled",
        "SnapStatusActive",
        "SystemConfinement",
        "SystemConfinementUnknown",
        "SystemConfinementStrict",
        "SystemConfinementPartial",
        "PublisherValidation",
        "PublisherValidationUnknown",
        "PublisherValidationUnproven",
        "PublisherValidationVerified",
        "PublisherValidationStarred",
        "MaintenanceKind",
        "MaintenanceKindUnknown",
        "MaintenanceKindDaemonRestart",
        "MaintenanceKindSystemRestart",
        "SnapNoticeType",
        "SnapNoticeTypeUnknown",
        "SnapNoticeTypeChangeUpdate",
        "SnapNoticeTypeRefreshInhibit",
        "SnapNoticeTypeSnapRunInhibit"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'AliasStatus'
        QtMocHelpers::EnumData<enum AliasStatus>(1, 1, QMC::EnumFlags{}).add({
            {    2, AliasStatus::AliasStatusUnknown },
            {    3, AliasStatus::AliasStatusDefault },
            {    4, AliasStatus::AliasStatusEnabled },
            {    5, AliasStatus::AliasStatusDisabled },
            {    6, AliasStatus::AliasStatusAuto },
            {    7, AliasStatus::AliasStatusManual },
        }),
        // enum 'DaemonType'
        QtMocHelpers::EnumData<enum DaemonType>(8, 8, QMC::EnumFlags{}).add({
            {    9, DaemonType::DaemonTypeNone },
            {   10, DaemonType::DaemonTypeUnknown },
            {   11, DaemonType::DaemonTypeSimple },
            {   12, DaemonType::DaemonTypeForking },
            {   13, DaemonType::DaemonTypeOneshot },
            {   14, DaemonType::DaemonTypeDbus },
            {   15, DaemonType::DaemonTypeNotify },
        }),
        // enum 'SnapConfinement'
        QtMocHelpers::EnumData<enum SnapConfinement>(16, 16, QMC::EnumFlags{}).add({
            {   17, SnapConfinement::SnapConfinementUnknown },
            {   18, SnapConfinement::SnapConfinementStrict },
            {   19, SnapConfinement::SnapConfinementDevmode },
            {   20, SnapConfinement::SnapConfinementClassic },
        }),
        // enum 'SnapType'
        QtMocHelpers::EnumData<enum SnapType>(21, 21, QMC::EnumFlags{}).add({
            {   22, SnapType::SnapTypeUnknown },
            {   23, SnapType::SnapTypeApp },
            {   24, SnapType::SnapTypeKernel },
            {   25, SnapType::SnapTypeGadget },
            {   26, SnapType::SnapTypeOperatingSystem },
            {   27, SnapType::SnapTypeCore },
            {   28, SnapType::SnapTypeBase },
            {   29, SnapType::SnapTypeSnapd },
        }),
        // enum 'SnapStatus'
        QtMocHelpers::EnumData<enum SnapStatus>(30, 30, QMC::EnumFlags{}).add({
            {   31, SnapStatus::SnapStatusUnknown },
            {   32, SnapStatus::SnapStatusAvailable },
            {   33, SnapStatus::SnapStatusPriced },
            {   34, SnapStatus::SnapStatusInstalled },
            {   35, SnapStatus::SnapStatusActive },
        }),
        // enum 'SystemConfinement'
        QtMocHelpers::EnumData<enum SystemConfinement>(36, 36, QMC::EnumFlags{}).add({
            {   37, SystemConfinement::SystemConfinementUnknown },
            {   38, SystemConfinement::SystemConfinementStrict },
            {   39, SystemConfinement::SystemConfinementPartial },
        }),
        // enum 'PublisherValidation'
        QtMocHelpers::EnumData<enum PublisherValidation>(40, 40, QMC::EnumFlags{}).add({
            {   41, PublisherValidation::PublisherValidationUnknown },
            {   42, PublisherValidation::PublisherValidationUnproven },
            {   43, PublisherValidation::PublisherValidationVerified },
            {   44, PublisherValidation::PublisherValidationStarred },
        }),
        // enum 'MaintenanceKind'
        QtMocHelpers::EnumData<enum MaintenanceKind>(45, 45, QMC::EnumFlags{}).add({
            {   46, MaintenanceKind::MaintenanceKindUnknown },
            {   47, MaintenanceKind::MaintenanceKindDaemonRestart },
            {   48, MaintenanceKind::MaintenanceKindSystemRestart },
        }),
        // enum 'SnapNoticeType'
        QtMocHelpers::EnumData<enum SnapNoticeType>(49, 49, QMC::EnumFlags{}).add({
            {   50, SnapNoticeType::SnapNoticeTypeUnknown },
            {   51, SnapNoticeType::SnapNoticeTypeChangeUpdate },
            {   52, SnapNoticeType::SnapNoticeTypeRefreshInhibit },
            {   53, SnapNoticeType::SnapNoticeTypeSnapRunInhibit },
        }),
    };
    return QtMocHelpers::metaObjectData<QSnapdEnums, qt_meta_tag_ZN11QSnapdEnumsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdEnums::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QSnapdEnumsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QSnapdEnumsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11QSnapdEnumsE_t>.metaTypes,
    nullptr
} };

void QSnapdEnums::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdEnums *>(_o);
    (void)_t;
    (void)_c;
    (void)_id;
    (void)_a;
}

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

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

int QSnapdEnums::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
QT_WARNING_POP
