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

#include "../../../../modemmanager-qt-6.25.0/src/modem.h"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'modem.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.11.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto ModemManager::Modem::qt_create_metaobjectdata<qt_meta_tag_ZN12ModemManager5ModemE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ModemManager::Modem",
        "bearerAdded",
        "",
        "bearer",
        "bearerRemoved",
        "bearersChanged",
        "simPathChanged",
        "oldPath",
        "newPath",
        "simSlotsChanged",
        "ModemManager::UIntList",
        "simSlots",
        "primarySimSlotChanged",
        "slot",
        "supportedCapabilitiesChanged",
        "QList<MMModemCapability>",
        "supportedCapabilities",
        "currentCapabilitiesChanged",
        "QFlags<MMModemCapability>",
        "currentCapabilities",
        "maxBearersChanged",
        "maxBearers",
        "maxActiveBearersChanged",
        "maxActiveBearers",
        "maxActiveMultiplexedBearersChanged",
        "maxActiveMultiplexedBearers",
        "manufacturerChanged",
        "manufacturer",
        "modelChanged",
        "model",
        "revisionChanged",
        "revision",
        "hardwareRevisionChanged",
        "hardwareRevision",
        "carrierConfigurationChanged",
        "carrierConfiguration",
        "carrierConfigurationRevisionChanged",
        "carrierConfigurationRevision",
        "deviceIdentifierChanged",
        "deviceIdentifier",
        "deviceChanged",
        "device",
        "physdevChanged",
        "physdev",
        "driversChanged",
        "drivers",
        "pluginChanged",
        "plugin",
        "primaryPortChanged",
        "primaryPort",
        "portsChanged",
        "ModemManager::PortList",
        "ports",
        "equipmentIdentifierChanged",
        "equipmentIdentifier",
        "unlockRequiredChanged",
        "MMModemLock",
        "unlockRequired",
        "unlockRetriesChanged",
        "ModemManager::UnlockRetriesMap",
        "unlockRetries",
        "stateFailedReasonChanged",
        "MMModemStateFailedReason",
        "stateFailedReason",
        "accessTechnologiesChanged",
        "QFlags<MMModemAccessTechnology>",
        "accessTechnologies",
        "signalQualityChanged",
        "ModemManager::SignalQualityPair",
        "signalQuality",
        "ownNumbersChanged",
        "ownNumbers",
        "powerStateChanged",
        "MMModemPowerState",
        "powerState",
        "supportedModesChanged",
        "ModemManager::SupportedModesType",
        "supportedModes",
        "currentModesChanged",
        "ModemManager::CurrentModesType",
        "currentModes",
        "supportedBandsChanged",
        "QList<MMModemBand>",
        "supportedBands",
        "currentBandsChanged",
        "supportedIpFamiliesChanged",
        "QFlags<MMBearerIpFamily>",
        "supportedIpFamilies",
        "stateChanged",
        "MMModemState",
        "oldState",
        "newState",
        "MMModemStateChangeReason",
        "reason"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'bearerAdded'
        QtMocHelpers::SignalData<void(const QString &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'bearerRemoved'
        QtMocHelpers::SignalData<void(const QString &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'bearersChanged'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'simPathChanged'
        QtMocHelpers::SignalData<void(const QString &, const QString &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 8 },
        }}),
        // Signal 'simSlotsChanged'
        QtMocHelpers::SignalData<void(const ModemManager::UIntList &)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 10, 11 },
        }}),
        // Signal 'primarySimSlotChanged'
        QtMocHelpers::SignalData<void(uint)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 13 },
        }}),
        // Signal 'supportedCapabilitiesChanged'
        QtMocHelpers::SignalData<void(const QList<MMModemCapability> &)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 15, 16 },
        }}),
        // Signal 'currentCapabilitiesChanged'
        QtMocHelpers::SignalData<void(const QFlags<MMModemCapability> &)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 18, 19 },
        }}),
        // Signal 'maxBearersChanged'
        QtMocHelpers::SignalData<void(uint)>(20, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 21 },
        }}),
        // Signal 'maxActiveBearersChanged'
        QtMocHelpers::SignalData<void(uint)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 23 },
        }}),
        // Signal 'maxActiveMultiplexedBearersChanged'
        QtMocHelpers::SignalData<void(uint)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 25 },
        }}),
        // Signal 'manufacturerChanged'
        QtMocHelpers::SignalData<void(const QString &)>(26, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 27 },
        }}),
        // Signal 'modelChanged'
        QtMocHelpers::SignalData<void(const QString &)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 29 },
        }}),
        // Signal 'revisionChanged'
        QtMocHelpers::SignalData<void(const QString &)>(30, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 31 },
        }}),
        // Signal 'hardwareRevisionChanged'
        QtMocHelpers::SignalData<void(const QString &)>(32, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 33 },
        }}),
        // Signal 'carrierConfigurationChanged'
        QtMocHelpers::SignalData<void(const QString &)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 35 },
        }}),
        // Signal 'carrierConfigurationRevisionChanged'
        QtMocHelpers::SignalData<void(const QString &)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 37 },
        }}),
        // Signal 'deviceIdentifierChanged'
        QtMocHelpers::SignalData<void(const QString &)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Signal 'deviceChanged'
        QtMocHelpers::SignalData<void(const QString &)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 41 },
        }}),
        // Signal 'physdevChanged'
        QtMocHelpers::SignalData<void(const QString &)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 43 },
        }}),
        // Signal 'driversChanged'
        QtMocHelpers::SignalData<void(const QStringList &)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 45 },
        }}),
        // Signal 'pluginChanged'
        QtMocHelpers::SignalData<void(const QString &)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 47 },
        }}),
        // Signal 'primaryPortChanged'
        QtMocHelpers::SignalData<void(const QString &)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 49 },
        }}),
        // Signal 'portsChanged'
        QtMocHelpers::SignalData<void(const ModemManager::PortList &)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 51, 52 },
        }}),
        // Signal 'equipmentIdentifierChanged'
        QtMocHelpers::SignalData<void(const QString &)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 54 },
        }}),
        // Signal 'unlockRequiredChanged'
        QtMocHelpers::SignalData<void(MMModemLock)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 56, 57 },
        }}),
        // Signal 'unlockRetriesChanged'
        QtMocHelpers::SignalData<void(const ModemManager::UnlockRetriesMap &)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 59, 60 },
        }}),
        // Signal 'stateFailedReasonChanged'
        QtMocHelpers::SignalData<void(MMModemStateFailedReason)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 62, 63 },
        }}),
        // Signal 'accessTechnologiesChanged'
        QtMocHelpers::SignalData<void(QFlags<MMModemAccessTechnology>)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 65, 66 },
        }}),
        // Signal 'signalQualityChanged'
        QtMocHelpers::SignalData<void(ModemManager::SignalQualityPair)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 68, 69 },
        }}),
        // Signal 'ownNumbersChanged'
        QtMocHelpers::SignalData<void(const QStringList &)>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 71 },
        }}),
        // Signal 'powerStateChanged'
        QtMocHelpers::SignalData<void(MMModemPowerState)>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 73, 74 },
        }}),
        // Signal 'supportedModesChanged'
        QtMocHelpers::SignalData<void(ModemManager::SupportedModesType)>(75, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 76, 77 },
        }}),
        // Signal 'currentModesChanged'
        QtMocHelpers::SignalData<void(ModemManager::CurrentModesType)>(78, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 79, 80 },
        }}),
        // Signal 'supportedBandsChanged'
        QtMocHelpers::SignalData<void(const QList<MMModemBand> &)>(81, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 82, 83 },
        }}),
        // Signal 'currentBandsChanged'
        QtMocHelpers::SignalData<void(const QList<MMModemBand> &)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 82, 83 },
        }}),
        // Signal 'supportedIpFamiliesChanged'
        QtMocHelpers::SignalData<void(QFlags<MMBearerIpFamily>)>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 86, 87 },
        }}),
        // Signal 'stateChanged'
        QtMocHelpers::SignalData<void(MMModemState, MMModemState, MMModemStateChangeReason)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 89, 90 }, { 0x80000000 | 89, 91 }, { 0x80000000 | 92, 93 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Modem, qt_meta_tag_ZN12ModemManager5ModemE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ModemManager::Modem::staticMetaObject = { {
    QMetaObject::SuperData::link<Interface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12ModemManager5ModemE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12ModemManager5ModemE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12ModemManager5ModemE_t>.metaTypes,
    nullptr
} };

void ModemManager::Modem::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Modem *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->bearerAdded((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->bearerRemoved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->bearersChanged(); break;
        case 3: _t->simPathChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 4: _t->simSlotsChanged((*reinterpret_cast<std::add_pointer_t<ModemManager::UIntList>>(_a[1]))); break;
        case 5: _t->primarySimSlotChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 6: _t->supportedCapabilitiesChanged((*reinterpret_cast<std::add_pointer_t<QList<MMModemCapability>>>(_a[1]))); break;
        case 7: _t->currentCapabilitiesChanged((*reinterpret_cast<std::add_pointer_t<QFlags<MMModemCapability>>>(_a[1]))); break;
        case 8: _t->maxBearersChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 9: _t->maxActiveBearersChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 10: _t->maxActiveMultiplexedBearersChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 11: _t->manufacturerChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 12: _t->modelChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 13: _t->revisionChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 14: _t->hardwareRevisionChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 15: _t->carrierConfigurationChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 16: _t->carrierConfigurationRevisionChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 17: _t->deviceIdentifierChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 18: _t->deviceChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 19: _t->physdevChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 20: _t->driversChanged((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 21: _t->pluginChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 22: _t->primaryPortChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 23: _t->portsChanged((*reinterpret_cast<std::add_pointer_t<ModemManager::PortList>>(_a[1]))); break;
        case 24: _t->equipmentIdentifierChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 25: _t->unlockRequiredChanged((*reinterpret_cast<std::add_pointer_t<MMModemLock>>(_a[1]))); break;
        case 26: _t->unlockRetriesChanged((*reinterpret_cast<std::add_pointer_t<ModemManager::UnlockRetriesMap>>(_a[1]))); break;
        case 27: _t->stateFailedReasonChanged((*reinterpret_cast<std::add_pointer_t<MMModemStateFailedReason>>(_a[1]))); break;
        case 28: _t->accessTechnologiesChanged((*reinterpret_cast<std::add_pointer_t<QFlags<MMModemAccessTechnology>>>(_a[1]))); break;
        case 29: _t->signalQualityChanged((*reinterpret_cast<std::add_pointer_t<ModemManager::SignalQualityPair>>(_a[1]))); break;
        case 30: _t->ownNumbersChanged((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 31: _t->powerStateChanged((*reinterpret_cast<std::add_pointer_t<MMModemPowerState>>(_a[1]))); break;
        case 32: _t->supportedModesChanged((*reinterpret_cast<std::add_pointer_t<ModemManager::SupportedModesType>>(_a[1]))); break;
        case 33: _t->currentModesChanged((*reinterpret_cast<std::add_pointer_t<ModemManager::CurrentModesType>>(_a[1]))); break;
        case 34: _t->supportedBandsChanged((*reinterpret_cast<std::add_pointer_t<QList<MMModemBand>>>(_a[1]))); break;
        case 35: _t->currentBandsChanged((*reinterpret_cast<std::add_pointer_t<QList<MMModemBand>>>(_a[1]))); break;
        case 36: _t->supportedIpFamiliesChanged((*reinterpret_cast<std::add_pointer_t<QFlags<MMBearerIpFamily>>>(_a[1]))); break;
        case 37: _t->stateChanged((*reinterpret_cast<std::add_pointer_t<MMModemState>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<MMModemState>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<MMModemStateChangeReason>>(_a[3]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<MMModemCapability> >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QFlags<MMModemCapability> >(); break;
            }
            break;
        case 23:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ModemManager::PortList >(); break;
            }
            break;
        case 25:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< MMModemLock >(); break;
            }
            break;
        case 26:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ModemManager::UnlockRetriesMap >(); break;
            }
            break;
        case 27:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< MMModemStateFailedReason >(); break;
            }
            break;
        case 28:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QFlags<MMModemAccessTechnology> >(); break;
            }
            break;
        case 29:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ModemManager::SignalQualityPair >(); break;
            }
            break;
        case 31:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< MMModemPowerState >(); break;
            }
            break;
        case 32:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ModemManager::SupportedModesType >(); break;
            }
            break;
        case 33:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ModemManager::CurrentModesType >(); break;
            }
            break;
        case 34:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<MMModemBand> >(); break;
            }
            break;
        case 35:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<MMModemBand> >(); break;
            }
            break;
        case 36:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QFlags<MMBearerIpFamily> >(); break;
            }
            break;
        case 37:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< MMModemState >(); break;
            case 2:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< MMModemStateChangeReason >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::bearerAdded, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::bearerRemoved, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)()>(_a, &Modem::bearersChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & , const QString & )>(_a, &Modem::simPathChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const ModemManager::UIntList & )>(_a, &Modem::simSlotsChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(uint )>(_a, &Modem::primarySimSlotChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QList<MMModemCapability> & )>(_a, &Modem::supportedCapabilitiesChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QFlags<MMModemCapability> & )>(_a, &Modem::currentCapabilitiesChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(uint )>(_a, &Modem::maxBearersChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(uint )>(_a, &Modem::maxActiveBearersChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(uint )>(_a, &Modem::maxActiveMultiplexedBearersChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::manufacturerChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::modelChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::revisionChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::hardwareRevisionChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::carrierConfigurationChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::carrierConfigurationRevisionChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::deviceIdentifierChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::deviceChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::physdevChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QStringList & )>(_a, &Modem::driversChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::pluginChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::primaryPortChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const ModemManager::PortList & )>(_a, &Modem::portsChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QString & )>(_a, &Modem::equipmentIdentifierChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(MMModemLock )>(_a, &Modem::unlockRequiredChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const ModemManager::UnlockRetriesMap & )>(_a, &Modem::unlockRetriesChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(MMModemStateFailedReason )>(_a, &Modem::stateFailedReasonChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(QFlags<MMModemAccessTechnology> )>(_a, &Modem::accessTechnologiesChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(ModemManager::SignalQualityPair )>(_a, &Modem::signalQualityChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QStringList & )>(_a, &Modem::ownNumbersChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(MMModemPowerState )>(_a, &Modem::powerStateChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(ModemManager::SupportedModesType )>(_a, &Modem::supportedModesChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(ModemManager::CurrentModesType )>(_a, &Modem::currentModesChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QList<MMModemBand> & )>(_a, &Modem::supportedBandsChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(const QList<MMModemBand> & )>(_a, &Modem::currentBandsChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(QFlags<MMBearerIpFamily> )>(_a, &Modem::supportedIpFamiliesChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (Modem::*)(MMModemState , MMModemState , MMModemStateChangeReason )>(_a, &Modem::stateChanged, 37))
            return;
    }
}

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

void *ModemManager::Modem::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12ModemManager5ModemE_t>.strings))
        return static_cast<void*>(this);
    return Interface::qt_metacast(_clname);
}

int ModemManager::Modem::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Interface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 38)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 38;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 38)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 38;
    }
    return _id;
}

// SIGNAL 0
void ModemManager::Modem::bearerAdded(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void ModemManager::Modem::bearerRemoved(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void ModemManager::Modem::bearersChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void ModemManager::Modem::simPathChanged(const QString & _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1, _t2);
}

// SIGNAL 4
void ModemManager::Modem::simSlotsChanged(const ModemManager::UIntList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void ModemManager::Modem::primarySimSlotChanged(uint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void ModemManager::Modem::supportedCapabilitiesChanged(const QList<MMModemCapability> & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void ModemManager::Modem::currentCapabilitiesChanged(const QFlags<MMModemCapability> & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void ModemManager::Modem::maxBearersChanged(uint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void ModemManager::Modem::maxActiveBearersChanged(uint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void ModemManager::Modem::maxActiveMultiplexedBearersChanged(uint _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void ModemManager::Modem::manufacturerChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void ModemManager::Modem::modelChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void ModemManager::Modem::revisionChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void ModemManager::Modem::hardwareRevisionChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void ModemManager::Modem::carrierConfigurationChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void ModemManager::Modem::carrierConfigurationRevisionChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void ModemManager::Modem::deviceIdentifierChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void ModemManager::Modem::deviceChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void ModemManager::Modem::physdevChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void ModemManager::Modem::driversChanged(const QStringList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void ModemManager::Modem::pluginChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

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

// SIGNAL 23
void ModemManager::Modem::portsChanged(const ModemManager::PortList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void ModemManager::Modem::equipmentIdentifierChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void ModemManager::Modem::unlockRequiredChanged(MMModemLock _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void ModemManager::Modem::unlockRetriesChanged(const ModemManager::UnlockRetriesMap & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

// SIGNAL 27
void ModemManager::Modem::stateFailedReasonChanged(MMModemStateFailedReason _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1);
}

// SIGNAL 28
void ModemManager::Modem::accessTechnologiesChanged(QFlags<MMModemAccessTechnology> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void ModemManager::Modem::signalQualityChanged(ModemManager::SignalQualityPair _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1);
}

// SIGNAL 30
void ModemManager::Modem::ownNumbersChanged(const QStringList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1);
}

// SIGNAL 31
void ModemManager::Modem::powerStateChanged(MMModemPowerState _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1);
}

// SIGNAL 32
void ModemManager::Modem::supportedModesChanged(ModemManager::SupportedModesType _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 32, nullptr, _t1);
}

// SIGNAL 33
void ModemManager::Modem::currentModesChanged(ModemManager::CurrentModesType _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 33, nullptr, _t1);
}

// SIGNAL 34
void ModemManager::Modem::supportedBandsChanged(const QList<MMModemBand> & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1);
}

// SIGNAL 35
void ModemManager::Modem::currentBandsChanged(const QList<MMModemBand> & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 35, nullptr, _t1);
}

// SIGNAL 36
void ModemManager::Modem::supportedIpFamiliesChanged(QFlags<MMBearerIpFamily> _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 36, nullptr, _t1);
}

// SIGNAL 37
void ModemManager::Modem::stateChanged(MMModemState _t1, MMModemState _t2, MMModemStateChangeReason _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 37, nullptr, _t1, _t2, _t3);
}
QT_WARNING_POP
