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

#include "../../../../../../src/network/nm/enums.hpp"
#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.hpp' 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_ZN2qs7network19NMConnectivityStateE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::network::NMConnectivityState::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7network19NMConnectivityStateE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::network::NMConnectivityState"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<NMConnectivityState, qt_meta_tag_ZN2qs7network19NMConnectivityStateE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject qs::network::NMConnectivityState::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network19NMConnectivityStateE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network19NMConnectivityStateE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7network19NMConnectivityStateE_t>.metaTypes,
    nullptr
} };

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

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

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

int qs::network::NMConnectivityState::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN2qs7network12NMDeviceTypeE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::network::NMDeviceType::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7network12NMDeviceTypeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::network::NMDeviceType",
        "Enum",
        "Unknown",
        "Ethernet",
        "Wifi",
        "Unused1",
        "Unused2",
        "Bluetooth",
        "OlpcMesh",
        "Wimax",
        "Modem",
        "InfiniBand",
        "Bond",
        "Vlan",
        "Adsl",
        "Bridge",
        "Generic",
        "Team",
        "Tun",
        "IpTunnel",
        "MacVlan",
        "VxLan",
        "Veth",
        "MacSec",
        "Dummy",
        "Ppp",
        "OvsInterface",
        "OvsPort",
        "OvsBridge",
        "Wpan",
        "Lowpan",
        "Wireguard",
        "WifiP2P",
        "Vrf",
        "Loopback",
        "Hsr",
        "IpVlan"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Enum'
        QtMocHelpers::EnumData<enum Enum>(1, 1, QMC::EnumFlags{}).add({
            {    2, Enum::Unknown },
            {    3, Enum::Ethernet },
            {    4, Enum::Wifi },
            {    5, Enum::Unused1 },
            {    6, Enum::Unused2 },
            {    7, Enum::Bluetooth },
            {    8, Enum::OlpcMesh },
            {    9, Enum::Wimax },
            {   10, Enum::Modem },
            {   11, Enum::InfiniBand },
            {   12, Enum::Bond },
            {   13, Enum::Vlan },
            {   14, Enum::Adsl },
            {   15, Enum::Bridge },
            {   16, Enum::Generic },
            {   17, Enum::Team },
            {   18, Enum::Tun },
            {   19, Enum::IpTunnel },
            {   20, Enum::MacVlan },
            {   21, Enum::VxLan },
            {   22, Enum::Veth },
            {   23, Enum::MacSec },
            {   24, Enum::Dummy },
            {   25, Enum::Ppp },
            {   26, Enum::OvsInterface },
            {   27, Enum::OvsPort },
            {   28, Enum::OvsBridge },
            {   29, Enum::Wpan },
            {   30, Enum::Lowpan },
            {   31, Enum::Wireguard },
            {   32, Enum::WifiP2P },
            {   33, Enum::Vrf },
            {   34, Enum::Loopback },
            {   35, Enum::Hsr },
            {   36, Enum::IpVlan },
        }),
    };
    return QtMocHelpers::metaObjectData<NMDeviceType, qt_meta_tag_ZN2qs7network12NMDeviceTypeE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject qs::network::NMDeviceType::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network12NMDeviceTypeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network12NMDeviceTypeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7network12NMDeviceTypeE_t>.metaTypes,
    nullptr
} };

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

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

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

int qs::network::NMDeviceType::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN2qs7network13NMDeviceStateE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::network::NMDeviceState::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7network13NMDeviceStateE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::network::NMDeviceState",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "Enum",
        "Unknown",
        "Unmanaged",
        "Unavailable",
        "Disconnected",
        "Prepare",
        "Config",
        "NeedAuth",
        "IPConfig",
        "IPCheck",
        "Secondaries",
        "Activated",
        "Deactivating",
        "Failed"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Enum'
        QtMocHelpers::EnumData<enum Enum>(5, 5, QMC::EnumFlags{}).add({
            {    6, Enum::Unknown },
            {    7, Enum::Unmanaged },
            {    8, Enum::Unavailable },
            {    9, Enum::Disconnected },
            {   10, Enum::Prepare },
            {   11, Enum::Config },
            {   12, Enum::NeedAuth },
            {   13, Enum::IPConfig },
            {   14, Enum::IPCheck },
            {   15, Enum::Secondaries },
            {   16, Enum::Activated },
            {   17, Enum::Deactivating },
            {   18, Enum::Failed },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<NMDeviceState, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject qs::network::NMDeviceState::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network13NMDeviceStateE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network13NMDeviceStateE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7network13NMDeviceStateE_t>.metaTypes,
    nullptr
} };

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

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

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

int qs::network::NMDeviceState::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN2qs7network19NMDeviceStateReasonE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::network::NMDeviceStateReason::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7network19NMDeviceStateReasonE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::network::NMDeviceStateReason",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "Enum",
        "None",
        "Unknown",
        "NowManaged",
        "NowUnmanaged",
        "ConfigFailed",
        "IpConfigUnavailable",
        "IpConfigExpired",
        "NoSecrets",
        "SupplicantDisconnect",
        "SupplicantConfigFailed",
        "SupplicantFailed",
        "SupplicantTimeout",
        "PppStartFailed",
        "PppDisconnect",
        "PppFailed",
        "DhcpStartFailed",
        "DhcpError",
        "DhcpFailed",
        "SharedStartFailed",
        "SharedFailed",
        "AutoIpStartFailed",
        "AutoIpError",
        "AutoIpFailed",
        "ModemBusy",
        "ModemNoDialTone",
        "ModemNoCarrier",
        "ModemDialTimeout",
        "ModemDialFailed",
        "ModemInitFailed",
        "GsmApnFailed",
        "GsmRegistrationNotSearching",
        "GsmRegistrationDenied",
        "GsmRegistrationTimeout",
        "GsmRegistrationFailed",
        "GsmPinCheckFailed",
        "FirmwareMissing",
        "Removed",
        "Sleeping",
        "ConnectionRemoved",
        "UserRequested",
        "Carrier",
        "ConnectionAssumed",
        "SupplicantAvailable",
        "ModemNotFound",
        "BtFailed",
        "GsmSimNotInserted",
        "GsmSimPinRequired",
        "GsmSimPukRequired",
        "GsmSimWrong",
        "InfinibandMode",
        "DependencyFailed",
        "Br2684Failed",
        "ModemManagerUnavailable",
        "SsidNotFound",
        "SecondaryConnectionFailed",
        "DcbFcoeFailed",
        "TeamdControlFailed",
        "ModemFailed",
        "ModemAvailable",
        "SimPinIncorrect",
        "NewActivation",
        "ParentChanged",
        "ParentManagedChanged",
        "OvsdbFailed",
        "IpAddressDuplicate",
        "IpMethodUnsupported",
        "SriovConfigurationFailed",
        "PeerNotFound",
        "DeviceHandlerFailed",
        "UnmanagedByDefault",
        "UnmanagedExternalDown",
        "UnmanagedLinkNotInit",
        "UnmanagedQuitting",
        "UnmanagedManagerDisabled",
        "UnmanagedUserConf",
        "UnmanagedUserExplicit",
        "UnmanagedUserSettings",
        "UnmanagedUserUdev",
        "NetworkingOff"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Enum'
        QtMocHelpers::EnumData<enum Enum>(5, 5, QMC::EnumFlags{}).add({
            {    6, Enum::None },
            {    7, Enum::Unknown },
            {    8, Enum::NowManaged },
            {    9, Enum::NowUnmanaged },
            {   10, Enum::ConfigFailed },
            {   11, Enum::IpConfigUnavailable },
            {   12, Enum::IpConfigExpired },
            {   13, Enum::NoSecrets },
            {   14, Enum::SupplicantDisconnect },
            {   15, Enum::SupplicantConfigFailed },
            {   16, Enum::SupplicantFailed },
            {   17, Enum::SupplicantTimeout },
            {   18, Enum::PppStartFailed },
            {   19, Enum::PppDisconnect },
            {   20, Enum::PppFailed },
            {   21, Enum::DhcpStartFailed },
            {   22, Enum::DhcpError },
            {   23, Enum::DhcpFailed },
            {   24, Enum::SharedStartFailed },
            {   25, Enum::SharedFailed },
            {   26, Enum::AutoIpStartFailed },
            {   27, Enum::AutoIpError },
            {   28, Enum::AutoIpFailed },
            {   29, Enum::ModemBusy },
            {   30, Enum::ModemNoDialTone },
            {   31, Enum::ModemNoCarrier },
            {   32, Enum::ModemDialTimeout },
            {   33, Enum::ModemDialFailed },
            {   34, Enum::ModemInitFailed },
            {   35, Enum::GsmApnFailed },
            {   36, Enum::GsmRegistrationNotSearching },
            {   37, Enum::GsmRegistrationDenied },
            {   38, Enum::GsmRegistrationTimeout },
            {   39, Enum::GsmRegistrationFailed },
            {   40, Enum::GsmPinCheckFailed },
            {   41, Enum::FirmwareMissing },
            {   42, Enum::Removed },
            {   43, Enum::Sleeping },
            {   44, Enum::ConnectionRemoved },
            {   45, Enum::UserRequested },
            {   46, Enum::Carrier },
            {   47, Enum::ConnectionAssumed },
            {   48, Enum::SupplicantAvailable },
            {   49, Enum::ModemNotFound },
            {   50, Enum::BtFailed },
            {   51, Enum::GsmSimNotInserted },
            {   52, Enum::GsmSimPinRequired },
            {   53, Enum::GsmSimPukRequired },
            {   54, Enum::GsmSimWrong },
            {   55, Enum::InfinibandMode },
            {   56, Enum::DependencyFailed },
            {   57, Enum::Br2684Failed },
            {   58, Enum::ModemManagerUnavailable },
            {   59, Enum::SsidNotFound },
            {   60, Enum::SecondaryConnectionFailed },
            {   61, Enum::DcbFcoeFailed },
            {   62, Enum::TeamdControlFailed },
            {   63, Enum::ModemFailed },
            {   64, Enum::ModemAvailable },
            {   65, Enum::SimPinIncorrect },
            {   66, Enum::NewActivation },
            {   67, Enum::ParentChanged },
            {   68, Enum::ParentManagedChanged },
            {   69, Enum::OvsdbFailed },
            {   70, Enum::IpAddressDuplicate },
            {   71, Enum::IpMethodUnsupported },
            {   72, Enum::SriovConfigurationFailed },
            {   73, Enum::PeerNotFound },
            {   74, Enum::DeviceHandlerFailed },
            {   75, Enum::UnmanagedByDefault },
            {   76, Enum::UnmanagedExternalDown },
            {   77, Enum::UnmanagedLinkNotInit },
            {   78, Enum::UnmanagedQuitting },
            {   79, Enum::UnmanagedManagerDisabled },
            {   80, Enum::UnmanagedUserConf },
            {   81, Enum::UnmanagedUserExplicit },
            {   82, Enum::UnmanagedUserSettings },
            {   83, Enum::UnmanagedUserUdev },
            {   84, Enum::NetworkingOff },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<NMDeviceStateReason, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject qs::network::NMDeviceStateReason::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network19NMDeviceStateReasonE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network19NMDeviceStateReasonE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7network19NMDeviceStateReasonE_t>.metaTypes,
    nullptr
} };

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

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

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

int qs::network::NMDeviceStateReason::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN2qs7network22NMDeviceInterfaceFlagsE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::network::NMDeviceInterfaceFlags::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7network22NMDeviceInterfaceFlagsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::network::NMDeviceInterfaceFlags",
        "Enum",
        "None",
        "Up",
        "LowerUp",
        "Promisc",
        "Carrier",
        "LldpClientEnabled"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Enum'
        QtMocHelpers::EnumData<enum Enum>(1, 1, QMC::EnumFlags{}).add({
            {    2, Enum::None },
            {    3, Enum::Up },
            {    4, Enum::LowerUp },
            {    5, Enum::Promisc },
            {    6, Enum::Carrier },
            {    7, Enum::LldpClientEnabled },
        }),
    };
    return QtMocHelpers::metaObjectData<NMDeviceInterfaceFlags, qt_meta_tag_ZN2qs7network22NMDeviceInterfaceFlagsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject qs::network::NMDeviceInterfaceFlags::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network22NMDeviceInterfaceFlagsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network22NMDeviceInterfaceFlagsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7network22NMDeviceInterfaceFlagsE_t>.metaTypes,
    nullptr
} };

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

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

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

int qs::network::NMDeviceInterfaceFlags::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN2qs7network22NMWirelessCapabilitiesE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::network::NMWirelessCapabilities::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7network22NMWirelessCapabilitiesE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::network::NMWirelessCapabilities",
        "Enum",
        "None",
        "CipherWep40",
        "CipherWep104",
        "CipherTkip",
        "CipherCcmp",
        "Wpa",
        "Rsn",
        "Ap",
        "Adhoc",
        "FreqValid",
        "Freq2Ghz",
        "Freq5Ghz",
        "Freq6Ghz",
        "Mesh",
        "IbssRsn"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Enum'
        QtMocHelpers::EnumData<enum Enum>(1, 1, QMC::EnumFlags{}).add({
            {    2, Enum::None },
            {    3, Enum::CipherWep40 },
            {    4, Enum::CipherWep104 },
            {    5, Enum::CipherTkip },
            {    6, Enum::CipherCcmp },
            {    7, Enum::Wpa },
            {    8, Enum::Rsn },
            {    9, Enum::Ap },
            {   10, Enum::Adhoc },
            {   11, Enum::FreqValid },
            {   12, Enum::Freq2Ghz },
            {   13, Enum::Freq5Ghz },
            {   14, Enum::Freq6Ghz },
            {   15, Enum::Mesh },
            {   16, Enum::IbssRsn },
        }),
    };
    return QtMocHelpers::metaObjectData<NMWirelessCapabilities, qt_meta_tag_ZN2qs7network22NMWirelessCapabilitiesE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject qs::network::NMWirelessCapabilities::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network22NMWirelessCapabilitiesE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network22NMWirelessCapabilitiesE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7network22NMWirelessCapabilitiesE_t>.metaTypes,
    nullptr
} };

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

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

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

int qs::network::NMWirelessCapabilities::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN2qs7network11NM80211ModeE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::network::NM80211Mode::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7network11NM80211ModeE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::network::NM80211Mode",
        "Enum",
        "Unknown",
        "Adhoc",
        "Infra",
        "Ap",
        "Mesh"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Enum'
        QtMocHelpers::EnumData<enum Enum>(1, 1, QMC::EnumFlags{}).add({
            {    2, Enum::Unknown },
            {    3, Enum::Adhoc },
            {    4, Enum::Infra },
            {    5, Enum::Ap },
            {    6, Enum::Mesh },
        }),
    };
    return QtMocHelpers::metaObjectData<NM80211Mode, qt_meta_tag_ZN2qs7network11NM80211ModeE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject qs::network::NM80211Mode::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network11NM80211ModeE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network11NM80211ModeE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7network11NM80211ModeE_t>.metaTypes,
    nullptr
} };

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

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

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

int qs::network::NM80211Mode::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN2qs7network14NM80211ApFlagsE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::network::NM80211ApFlags::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7network14NM80211ApFlagsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::network::NM80211ApFlags",
        "Enum",
        "None",
        "Privacy",
        "Wps",
        "WpsPbc",
        "WpsPin"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Enum'
        QtMocHelpers::EnumData<enum Enum>(1, 1, QMC::EnumFlags{}).add({
            {    2, Enum::None },
            {    3, Enum::Privacy },
            {    4, Enum::Wps },
            {    5, Enum::WpsPbc },
            {    6, Enum::WpsPin },
        }),
    };
    return QtMocHelpers::metaObjectData<NM80211ApFlags, qt_meta_tag_ZN2qs7network14NM80211ApFlagsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject qs::network::NM80211ApFlags::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network14NM80211ApFlagsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network14NM80211ApFlagsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7network14NM80211ApFlagsE_t>.metaTypes,
    nullptr
} };

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

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

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

int qs::network::NM80211ApFlags::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN2qs7network22NM80211ApSecurityFlagsE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::network::NM80211ApSecurityFlags::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7network22NM80211ApSecurityFlagsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::network::NM80211ApSecurityFlags",
        "Enum",
        "None",
        "PairWep40",
        "PairWep104",
        "PairTkip",
        "PairCcmp",
        "GroupWep40",
        "GroupWep104",
        "GroupTkip",
        "GroupCcmp",
        "KeyMgmtPsk",
        "KeyMgmt8021x",
        "KeyMgmtSae",
        "KeyMgmtOwe",
        "KeyMgmtOweTm",
        "KeyMgmtEapSuiteB192"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Enum'
        QtMocHelpers::EnumData<enum Enum>(1, 1, QMC::EnumFlags{}).add({
            {    2, Enum::None },
            {    3, Enum::PairWep40 },
            {    4, Enum::PairWep104 },
            {    5, Enum::PairTkip },
            {    6, Enum::PairCcmp },
            {    7, Enum::GroupWep40 },
            {    8, Enum::GroupWep104 },
            {    9, Enum::GroupTkip },
            {   10, Enum::GroupCcmp },
            {   11, Enum::KeyMgmtPsk },
            {   12, Enum::KeyMgmt8021x },
            {   13, Enum::KeyMgmtSae },
            {   14, Enum::KeyMgmtOwe },
            {   15, Enum::KeyMgmtOweTm },
            {   16, Enum::KeyMgmtEapSuiteB192 },
        }),
    };
    return QtMocHelpers::metaObjectData<NM80211ApSecurityFlags, qt_meta_tag_ZN2qs7network22NM80211ApSecurityFlagsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject qs::network::NM80211ApSecurityFlags::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network22NM80211ApSecurityFlagsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network22NM80211ApSecurityFlagsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7network22NM80211ApSecurityFlagsE_t>.metaTypes,
    nullptr
} };

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

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

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

int qs::network::NM80211ApSecurityFlags::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN2qs7network17NMConnectionStateE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::network::NMConnectionState::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7network17NMConnectionStateE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::network::NMConnectionState",
        "Enum",
        "Unknown",
        "Activating",
        "Activated",
        "Deactivating",
        "Deactivated"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Enum'
        QtMocHelpers::EnumData<enum Enum>(1, 1, QMC::EnumFlags{}).add({
            {    2, Enum::Unknown },
            {    3, Enum::Activating },
            {    4, Enum::Activated },
            {    5, Enum::Deactivating },
            {    6, Enum::Deactivated },
        }),
    };
    return QtMocHelpers::metaObjectData<NMConnectionState, qt_meta_tag_ZN2qs7network17NMConnectionStateE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject qs::network::NMConnectionState::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network17NMConnectionStateE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network17NMConnectionStateE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7network17NMConnectionStateE_t>.metaTypes,
    nullptr
} };

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

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

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

int qs::network::NMConnectionState::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN2qs7network23NMConnectionStateReasonE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::network::NMConnectionStateReason::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7network23NMConnectionStateReasonE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::network::NMConnectionStateReason",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "Enum",
        "Unknown",
        "None",
        "UserDisconnected",
        "DeviceDisconnected",
        "ServiceStopped",
        "IpConfigInvalid",
        "ConnectTimeout",
        "ServiceStartTimeout",
        "ServiceStartFailed",
        "NoSecrets",
        "LoginFailed",
        "ConnectionRemoved",
        "DependencyFailed",
        "DeviceRealizeFailed",
        "DeviceRemoved"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Enum'
        QtMocHelpers::EnumData<enum Enum>(5, 5, QMC::EnumFlags{}).add({
            {    6, Enum::Unknown },
            {    7, Enum::None },
            {    8, Enum::UserDisconnected },
            {    9, Enum::DeviceDisconnected },
            {   10, Enum::ServiceStopped },
            {   11, Enum::IpConfigInvalid },
            {   12, Enum::ConnectTimeout },
            {   13, Enum::ServiceStartTimeout },
            {   14, Enum::ServiceStartFailed },
            {   15, Enum::NoSecrets },
            {   16, Enum::LoginFailed },
            {   17, Enum::ConnectionRemoved },
            {   18, Enum::DependencyFailed },
            {   19, Enum::DeviceRealizeFailed },
            {   20, Enum::DeviceRemoved },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<NMConnectionStateReason, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject qs::network::NMConnectionStateReason::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network23NMConnectionStateReasonE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7network23NMConnectionStateReasonE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7network23NMConnectionStateReasonE_t>.metaTypes,
    nullptr
} };

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

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

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

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