/****************************************************************************
** Meta object code from reading C++ file 'qmqttclient.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 "../../../../../qtmqtt/src/mqtt/qmqttclient.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 'qmqttclient.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_ZN11QMqttClientE_t {};
} // unnamed namespace

template <> constexpr inline auto QMqttClient::qt_create_metaobjectdata<qt_meta_tag_ZN11QMqttClientE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QMqttClient",
        "connected",
        "",
        "disconnected",
        "messageReceived",
        "message",
        "QMqttTopicName",
        "topic",
        "messageStatusChanged",
        "id",
        "QMqtt::MessageStatus",
        "s",
        "QMqttMessageStatusProperties",
        "properties",
        "messageSent",
        "pingResponseReceived",
        "brokerSessionRestored",
        "hostnameChanged",
        "hostname",
        "portChanged",
        "port",
        "clientIdChanged",
        "clientId",
        "keepAliveChanged",
        "keepAlive",
        "protocolVersionChanged",
        "ProtocolVersion",
        "protocolVersion",
        "stateChanged",
        "ClientState",
        "state",
        "errorChanged",
        "ClientError",
        "error",
        "usernameChanged",
        "username",
        "passwordChanged",
        "password",
        "cleanSessionChanged",
        "cleanSession",
        "willTopicChanged",
        "willTopic",
        "willQoSChanged",
        "willQoS",
        "willMessageChanged",
        "willMessage",
        "willRetainChanged",
        "willRetain",
        "autoKeepAliveChanged",
        "autoKeepAlive",
        "authenticationRequested",
        "QMqttAuthenticationProperties",
        "p",
        "authenticationFinished",
        "setHostname",
        "setPort",
        "setClientId",
        "setKeepAlive",
        "setProtocolVersion",
        "setState",
        "setError",
        "setUsername",
        "setPassword",
        "setCleanSession",
        "setWillTopic",
        "setWillQoS",
        "setWillMessage",
        "setWillRetain",
        "setAutoKeepAlive",
        "publish",
        "qos",
        "retain",
        "QMqttPublishProperties",
        "connectToHost",
        "connectToHostWebSocket",
        "QWebSocket*",
        "webSocket",
        "connectToHostWebSocketEncrypted",
        "disconnectFromHost",
        "Disconnected",
        "Connecting",
        "Connected",
        "NoError",
        "InvalidProtocolVersion",
        "IdRejected",
        "ServerUnavailable",
        "BadUsernameOrPassword",
        "NotAuthorized",
        "TransportInvalid",
        "ProtocolViolation",
        "UnknownError",
        "Mqtt5SpecificError",
        "MQTT_3_1",
        "MQTT_3_1_1",
        "MQTT_5_0"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'connected'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'disconnected'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'messageReceived'
        QtMocHelpers::SignalData<void(const QByteArray &, const QMqttTopicName &)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 5 }, { 0x80000000 | 6, 7 },
        }}),
        // Signal 'messageReceived'
        QtMocHelpers::SignalData<void(const QByteArray &)>(4, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QByteArray, 5 },
        }}),
        // Signal 'messageStatusChanged'
        QtMocHelpers::SignalData<void(qint32, QMqtt::MessageStatus, const QMqttMessageStatusProperties &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 9 }, { 0x80000000 | 10, 11 }, { 0x80000000 | 12, 13 },
        }}),
        // Signal 'messageSent'
        QtMocHelpers::SignalData<void(qint32)>(14, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 9 },
        }}),
        // Signal 'pingResponseReceived'
        QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'brokerSessionRestored'
        QtMocHelpers::SignalData<void()>(16, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'hostnameChanged'
        QtMocHelpers::SignalData<void(QString)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 18 },
        }}),
        // Signal 'portChanged'
        QtMocHelpers::SignalData<void(quint16)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UShort, 20 },
        }}),
        // Signal 'clientIdChanged'
        QtMocHelpers::SignalData<void(QString)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 22 },
        }}),
        // Signal 'keepAliveChanged'
        QtMocHelpers::SignalData<void(quint16)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UShort, 24 },
        }}),
        // Signal 'protocolVersionChanged'
        QtMocHelpers::SignalData<void(enum ProtocolVersion)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 26, 27 },
        }}),
        // Signal 'stateChanged'
        QtMocHelpers::SignalData<void(enum ClientState)>(28, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 29, 30 },
        }}),
        // Signal 'errorChanged'
        QtMocHelpers::SignalData<void(enum ClientError)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 32, 33 },
        }}),
        // Signal 'usernameChanged'
        QtMocHelpers::SignalData<void(QString)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 35 },
        }}),
        // Signal 'passwordChanged'
        QtMocHelpers::SignalData<void(QString)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 37 },
        }}),
        // Signal 'cleanSessionChanged'
        QtMocHelpers::SignalData<void(bool)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 39 },
        }}),
        // Signal 'willTopicChanged'
        QtMocHelpers::SignalData<void(QString)>(40, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 41 },
        }}),
        // Signal 'willQoSChanged'
        QtMocHelpers::SignalData<void(quint8)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UChar, 43 },
        }}),
        // Signal 'willMessageChanged'
        QtMocHelpers::SignalData<void(QByteArray)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 45 },
        }}),
        // Signal 'willRetainChanged'
        QtMocHelpers::SignalData<void(bool)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 47 },
        }}),
        // Signal 'autoKeepAliveChanged'
        QtMocHelpers::SignalData<void(bool)>(48, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 49 },
        }}),
        // Signal 'authenticationRequested'
        QtMocHelpers::SignalData<void(const QMqttAuthenticationProperties &)>(50, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 51, 52 },
        }}),
        // Signal 'authenticationFinished'
        QtMocHelpers::SignalData<void(const QMqttAuthenticationProperties &)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 51, 52 },
        }}),
        // Slot 'setHostname'
        QtMocHelpers::SlotData<void(const QString &)>(54, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 18 },
        }}),
        // Slot 'setPort'
        QtMocHelpers::SlotData<void(quint16)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UShort, 20 },
        }}),
        // Slot 'setClientId'
        QtMocHelpers::SlotData<void(const QString &)>(56, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 22 },
        }}),
        // Slot 'setKeepAlive'
        QtMocHelpers::SlotData<void(quint16)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UShort, 24 },
        }}),
        // Slot 'setProtocolVersion'
        QtMocHelpers::SlotData<void(enum ProtocolVersion)>(58, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 26, 27 },
        }}),
        // Slot 'setState'
        QtMocHelpers::SlotData<void(enum ClientState)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 29, 30 },
        }}),
        // Slot 'setError'
        QtMocHelpers::SlotData<void(enum ClientError)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 32, 33 },
        }}),
        // Slot 'setUsername'
        QtMocHelpers::SlotData<void(const QString &)>(61, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 35 },
        }}),
        // Slot 'setPassword'
        QtMocHelpers::SlotData<void(const QString &)>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 37 },
        }}),
        // Slot 'setCleanSession'
        QtMocHelpers::SlotData<void(bool)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 39 },
        }}),
        // Slot 'setWillTopic'
        QtMocHelpers::SlotData<void(const QString &)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 41 },
        }}),
        // Slot 'setWillQoS'
        QtMocHelpers::SlotData<void(quint8)>(65, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UChar, 43 },
        }}),
        // Slot 'setWillMessage'
        QtMocHelpers::SlotData<void(const QByteArray &)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 45 },
        }}),
        // Slot 'setWillRetain'
        QtMocHelpers::SlotData<void(bool)>(67, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 47 },
        }}),
        // Slot 'setAutoKeepAlive'
        QtMocHelpers::SlotData<void(bool)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 49 },
        }}),
        // Method 'publish'
        QtMocHelpers::MethodData<qint32(const QMqttTopicName &, const QByteArray &, quint8, bool)>(69, 2, QMC::AccessPublic, QMetaType::Int, {{
            { 0x80000000 | 6, 7 }, { QMetaType::QByteArray, 5 }, { QMetaType::UChar, 70 }, { QMetaType::Bool, 71 },
        }}),
        // Method 'publish'
        QtMocHelpers::MethodData<qint32(const QMqttTopicName &, const QByteArray &, quint8)>(69, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { 0x80000000 | 6, 7 }, { QMetaType::QByteArray, 5 }, { QMetaType::UChar, 70 },
        }}),
        // Method 'publish'
        QtMocHelpers::MethodData<qint32(const QMqttTopicName &, const QByteArray &)>(69, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { 0x80000000 | 6, 7 }, { QMetaType::QByteArray, 5 },
        }}),
        // Method 'publish'
        QtMocHelpers::MethodData<qint32(const QMqttTopicName &)>(69, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Method 'publish'
        QtMocHelpers::MethodData<qint32(const QMqttTopicName &, const QMqttPublishProperties &, const QByteArray &, quint8, bool)>(69, 2, QMC::AccessPublic, QMetaType::Int, {{
            { 0x80000000 | 6, 7 }, { 0x80000000 | 72, 13 }, { QMetaType::QByteArray, 5 }, { QMetaType::UChar, 70 },
            { QMetaType::Bool, 71 },
        }}),
        // Method 'publish'
        QtMocHelpers::MethodData<qint32(const QMqttTopicName &, const QMqttPublishProperties &, const QByteArray &, quint8)>(69, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { 0x80000000 | 6, 7 }, { 0x80000000 | 72, 13 }, { QMetaType::QByteArray, 5 }, { QMetaType::UChar, 70 },
        }}),
        // Method 'publish'
        QtMocHelpers::MethodData<qint32(const QMqttTopicName &, const QMqttPublishProperties &, const QByteArray &)>(69, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { 0x80000000 | 6, 7 }, { 0x80000000 | 72, 13 }, { QMetaType::QByteArray, 5 },
        }}),
        // Method 'publish'
        QtMocHelpers::MethodData<qint32(const QMqttTopicName &, const QMqttPublishProperties &)>(69, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Int, {{
            { 0x80000000 | 6, 7 }, { 0x80000000 | 72, 13 },
        }}),
        // Method 'connectToHost'
        QtMocHelpers::MethodData<void()>(73, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'connectToHostWebSocket'
        QtMocHelpers::MethodData<void(QWebSocket *)>(74, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 75, 76 },
        }}),
        // Method 'connectToHostWebSocket'
        QtMocHelpers::MethodData<void()>(74, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'connectToHostWebSocketEncrypted'
        QtMocHelpers::MethodData<void(QWebSocket *)>(77, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 75, 76 },
        }}),
        // Method 'connectToHostWebSocketEncrypted'
        QtMocHelpers::MethodData<void()>(77, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'disconnectFromHost'
        QtMocHelpers::MethodData<void()>(78, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'clientId'
        QtMocHelpers::PropertyData<QString>(22, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'hostname'
        QtMocHelpers::PropertyData<QString>(18, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'port'
        QtMocHelpers::PropertyData<quint16>(20, QMetaType::UShort, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'keepAlive'
        QtMocHelpers::PropertyData<quint16>(24, QMetaType::UShort, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 11),
        // property 'protocolVersion'
        QtMocHelpers::PropertyData<enum ProtocolVersion>(27, 0x80000000 | 26, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 12),
        // property 'state'
        QtMocHelpers::PropertyData<enum ClientState>(30, 0x80000000 | 29, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 13),
        // property 'error'
        QtMocHelpers::PropertyData<enum ClientError>(33, 0x80000000 | 32, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 14),
        // property 'username'
        QtMocHelpers::PropertyData<QString>(35, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'password'
        QtMocHelpers::PropertyData<QString>(37, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'cleanSession'
        QtMocHelpers::PropertyData<bool>(39, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'willTopic'
        QtMocHelpers::PropertyData<QString>(41, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'willMessage'
        QtMocHelpers::PropertyData<QByteArray>(45, QMetaType::QByteArray, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 20),
        // property 'willQoS'
        QtMocHelpers::PropertyData<quint8>(43, QMetaType::UChar, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 19),
        // property 'willRetain'
        QtMocHelpers::PropertyData<bool>(47, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 21),
        // property 'autoKeepAlive'
        QtMocHelpers::PropertyData<bool>(49, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 22),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'ClientState'
        QtMocHelpers::EnumData<enum ClientState>(29, 29, QMC::EnumFlags{}).add({
            {   79, ClientState::Disconnected },
            {   80, ClientState::Connecting },
            {   81, ClientState::Connected },
        }),
        // enum 'ClientError'
        QtMocHelpers::EnumData<enum ClientError>(32, 32, QMC::EnumFlags{}).add({
            {   82, ClientError::NoError },
            {   83, ClientError::InvalidProtocolVersion },
            {   84, ClientError::IdRejected },
            {   85, ClientError::ServerUnavailable },
            {   86, ClientError::BadUsernameOrPassword },
            {   87, ClientError::NotAuthorized },
            {   88, ClientError::TransportInvalid },
            {   89, ClientError::ProtocolViolation },
            {   90, ClientError::UnknownError },
            {   91, ClientError::Mqtt5SpecificError },
        }),
        // enum 'ProtocolVersion'
        QtMocHelpers::EnumData<enum ProtocolVersion>(26, 26, QMC::EnumFlags{}).add({
            {   92, ProtocolVersion::MQTT_3_1 },
            {   93, ProtocolVersion::MQTT_3_1_1 },
            {   94, ProtocolVersion::MQTT_5_0 },
        }),
    };
    return QtMocHelpers::metaObjectData<QMqttClient, qt_meta_tag_ZN11QMqttClientE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QMqttClient::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QMqttClientE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11QMqttClientE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11QMqttClientE_t>.metaTypes,
    nullptr
} };

void QMqttClient::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QMqttClient *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->connected(); break;
        case 1: _t->disconnected(); break;
        case 2: _t->messageReceived((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QMqttTopicName>>(_a[2]))); break;
        case 3: _t->messageReceived((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 4: _t->messageStatusChanged((*reinterpret_cast<std::add_pointer_t<qint32>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QMqtt::MessageStatus>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QMqttMessageStatusProperties>>(_a[3]))); break;
        case 5: _t->messageSent((*reinterpret_cast<std::add_pointer_t<qint32>>(_a[1]))); break;
        case 6: _t->pingResponseReceived(); break;
        case 7: _t->brokerSessionRestored(); break;
        case 8: _t->hostnameChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 9: _t->portChanged((*reinterpret_cast<std::add_pointer_t<quint16>>(_a[1]))); break;
        case 10: _t->clientIdChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 11: _t->keepAliveChanged((*reinterpret_cast<std::add_pointer_t<quint16>>(_a[1]))); break;
        case 12: _t->protocolVersionChanged((*reinterpret_cast<std::add_pointer_t<enum ProtocolVersion>>(_a[1]))); break;
        case 13: _t->stateChanged((*reinterpret_cast<std::add_pointer_t<enum ClientState>>(_a[1]))); break;
        case 14: _t->errorChanged((*reinterpret_cast<std::add_pointer_t<enum ClientError>>(_a[1]))); break;
        case 15: _t->usernameChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 16: _t->passwordChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 17: _t->cleanSessionChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->willTopicChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 19: _t->willQoSChanged((*reinterpret_cast<std::add_pointer_t<quint8>>(_a[1]))); break;
        case 20: _t->willMessageChanged((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 21: _t->willRetainChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 22: _t->autoKeepAliveChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 23: _t->authenticationRequested((*reinterpret_cast<std::add_pointer_t<QMqttAuthenticationProperties>>(_a[1]))); break;
        case 24: _t->authenticationFinished((*reinterpret_cast<std::add_pointer_t<QMqttAuthenticationProperties>>(_a[1]))); break;
        case 25: _t->setHostname((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 26: _t->setPort((*reinterpret_cast<std::add_pointer_t<quint16>>(_a[1]))); break;
        case 27: _t->setClientId((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 28: _t->setKeepAlive((*reinterpret_cast<std::add_pointer_t<quint16>>(_a[1]))); break;
        case 29: _t->setProtocolVersion((*reinterpret_cast<std::add_pointer_t<enum ProtocolVersion>>(_a[1]))); break;
        case 30: _t->setState((*reinterpret_cast<std::add_pointer_t<enum ClientState>>(_a[1]))); break;
        case 31: _t->setError((*reinterpret_cast<std::add_pointer_t<enum ClientError>>(_a[1]))); break;
        case 32: _t->setUsername((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 33: _t->setPassword((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 34: _t->setCleanSession((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 35: _t->setWillTopic((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 36: _t->setWillQoS((*reinterpret_cast<std::add_pointer_t<quint8>>(_a[1]))); break;
        case 37: _t->setWillMessage((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 38: _t->setWillRetain((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 39: _t->setAutoKeepAlive((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 40: { qint32 _r = _t->publish((*reinterpret_cast<std::add_pointer_t<QMqttTopicName>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<quint8>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])));
            if (_a[0]) *reinterpret_cast<qint32*>(_a[0]) = std::move(_r); }  break;
        case 41: { qint32 _r = _t->publish((*reinterpret_cast<std::add_pointer_t<QMqttTopicName>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<quint8>>(_a[3])));
            if (_a[0]) *reinterpret_cast<qint32*>(_a[0]) = std::move(_r); }  break;
        case 42: { qint32 _r = _t->publish((*reinterpret_cast<std::add_pointer_t<QMqttTopicName>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[2])));
            if (_a[0]) *reinterpret_cast<qint32*>(_a[0]) = std::move(_r); }  break;
        case 43: { qint32 _r = _t->publish((*reinterpret_cast<std::add_pointer_t<QMqttTopicName>>(_a[1])));
            if (_a[0]) *reinterpret_cast<qint32*>(_a[0]) = std::move(_r); }  break;
        case 44: { qint32 _r = _t->publish((*reinterpret_cast<std::add_pointer_t<QMqttTopicName>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QMqttPublishProperties>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<quint8>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[5])));
            if (_a[0]) *reinterpret_cast<qint32*>(_a[0]) = std::move(_r); }  break;
        case 45: { qint32 _r = _t->publish((*reinterpret_cast<std::add_pointer_t<QMqttTopicName>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QMqttPublishProperties>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<quint8>>(_a[4])));
            if (_a[0]) *reinterpret_cast<qint32*>(_a[0]) = std::move(_r); }  break;
        case 46: { qint32 _r = _t->publish((*reinterpret_cast<std::add_pointer_t<QMqttTopicName>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QMqttPublishProperties>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[3])));
            if (_a[0]) *reinterpret_cast<qint32*>(_a[0]) = std::move(_r); }  break;
        case 47: { qint32 _r = _t->publish((*reinterpret_cast<std::add_pointer_t<QMqttTopicName>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QMqttPublishProperties>>(_a[2])));
            if (_a[0]) *reinterpret_cast<qint32*>(_a[0]) = std::move(_r); }  break;
        case 48: _t->connectToHost(); break;
        case 49: _t->connectToHostWebSocket((*reinterpret_cast<std::add_pointer_t<QWebSocket*>>(_a[1]))); break;
        case 50: _t->connectToHostWebSocket(); break;
        case 51: _t->connectToHostWebSocketEncrypted((*reinterpret_cast<std::add_pointer_t<QWebSocket*>>(_a[1]))); break;
        case 52: _t->connectToHostWebSocketEncrypted(); break;
        case 53: _t->disconnectFromHost(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QMqttTopicName >(); break;
            }
            break;
        case 40:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QMqttTopicName >(); break;
            }
            break;
        case 41:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QMqttTopicName >(); break;
            }
            break;
        case 42:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QMqttTopicName >(); break;
            }
            break;
        case 43:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QMqttTopicName >(); break;
            }
            break;
        case 44:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QMqttTopicName >(); break;
            }
            break;
        case 45:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QMqttTopicName >(); break;
            }
            break;
        case 46:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QMqttTopicName >(); break;
            }
            break;
        case 47:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QMqttTopicName >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)()>(_a, &QMqttClient::connected, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)()>(_a, &QMqttClient::disconnected, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(const QByteArray & , const QMqttTopicName & )>(_a, &QMqttClient::messageReceived, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(qint32 , QMqtt::MessageStatus , const QMqttMessageStatusProperties & )>(_a, &QMqttClient::messageStatusChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(qint32 )>(_a, &QMqttClient::messageSent, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)()>(_a, &QMqttClient::pingResponseReceived, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)()>(_a, &QMqttClient::brokerSessionRestored, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(QString )>(_a, &QMqttClient::hostnameChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(quint16 )>(_a, &QMqttClient::portChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(QString )>(_a, &QMqttClient::clientIdChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(quint16 )>(_a, &QMqttClient::keepAliveChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(ProtocolVersion )>(_a, &QMqttClient::protocolVersionChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(ClientState )>(_a, &QMqttClient::stateChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(ClientError )>(_a, &QMqttClient::errorChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(QString )>(_a, &QMqttClient::usernameChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(QString )>(_a, &QMqttClient::passwordChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(bool )>(_a, &QMqttClient::cleanSessionChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(QString )>(_a, &QMqttClient::willTopicChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(quint8 )>(_a, &QMqttClient::willQoSChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(QByteArray )>(_a, &QMqttClient::willMessageChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(bool )>(_a, &QMqttClient::willRetainChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(bool )>(_a, &QMqttClient::autoKeepAliveChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(const QMqttAuthenticationProperties & )>(_a, &QMqttClient::authenticationRequested, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (QMqttClient::*)(const QMqttAuthenticationProperties & )>(_a, &QMqttClient::authenticationFinished, 24))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->clientId(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->hostname(); break;
        case 2: *reinterpret_cast<quint16*>(_v) = _t->port(); break;
        case 3: *reinterpret_cast<quint16*>(_v) = _t->keepAlive(); break;
        case 4: *reinterpret_cast<enum ProtocolVersion*>(_v) = _t->protocolVersion(); break;
        case 5: *reinterpret_cast<enum ClientState*>(_v) = _t->state(); break;
        case 6: *reinterpret_cast<enum ClientError*>(_v) = _t->error(); break;
        case 7: *reinterpret_cast<QString*>(_v) = _t->username(); break;
        case 8: *reinterpret_cast<QString*>(_v) = _t->password(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->cleanSession(); break;
        case 10: *reinterpret_cast<QString*>(_v) = _t->willTopic(); break;
        case 11: *reinterpret_cast<QByteArray*>(_v) = _t->willMessage(); break;
        case 12: *reinterpret_cast<quint8*>(_v) = _t->willQoS(); break;
        case 13: *reinterpret_cast<bool*>(_v) = _t->willRetain(); break;
        case 14: *reinterpret_cast<bool*>(_v) = _t->autoKeepAlive(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setClientId(*reinterpret_cast<QString*>(_v)); break;
        case 1: _t->setHostname(*reinterpret_cast<QString*>(_v)); break;
        case 2: _t->setPort(*reinterpret_cast<quint16*>(_v)); break;
        case 3: _t->setKeepAlive(*reinterpret_cast<quint16*>(_v)); break;
        case 4: _t->setProtocolVersion(*reinterpret_cast<enum ProtocolVersion*>(_v)); break;
        case 5: _t->setState(*reinterpret_cast<enum ClientState*>(_v)); break;
        case 6: _t->setError(*reinterpret_cast<enum ClientError*>(_v)); break;
        case 7: _t->setUsername(*reinterpret_cast<QString*>(_v)); break;
        case 8: _t->setPassword(*reinterpret_cast<QString*>(_v)); break;
        case 9: _t->setCleanSession(*reinterpret_cast<bool*>(_v)); break;
        case 10: _t->setWillTopic(*reinterpret_cast<QString*>(_v)); break;
        case 11: _t->setWillMessage(*reinterpret_cast<QByteArray*>(_v)); break;
        case 12: _t->setWillQoS(*reinterpret_cast<quint8*>(_v)); break;
        case 13: _t->setWillRetain(*reinterpret_cast<bool*>(_v)); break;
        case 14: _t->setAutoKeepAlive(*reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}

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

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

int QMqttClient::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 < 54)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 54;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 54)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 54;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 15;
    }
    return _id;
}

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

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

// SIGNAL 2
void QMqttClient::messageReceived(const QByteArray & _t1, const QMqttTopicName & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1, _t2);
}

// SIGNAL 4
void QMqttClient::messageStatusChanged(qint32 _t1, QMqtt::MessageStatus _t2, const QMqttMessageStatusProperties & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1, _t2, _t3);
}

// SIGNAL 5
void QMqttClient::messageSent(qint32 _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

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

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

// SIGNAL 8
void QMqttClient::hostnameChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void QMqttClient::portChanged(quint16 _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void QMqttClient::clientIdChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void QMqttClient::keepAliveChanged(quint16 _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void QMqttClient::protocolVersionChanged(ProtocolVersion _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void QMqttClient::stateChanged(ClientState _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void QMqttClient::errorChanged(ClientError _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void QMqttClient::usernameChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void QMqttClient::passwordChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void QMqttClient::cleanSessionChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void QMqttClient::willTopicChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void QMqttClient::willQoSChanged(quint8 _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

// SIGNAL 20
void QMqttClient::willMessageChanged(QByteArray _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void QMqttClient::willRetainChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void QMqttClient::autoKeepAliveChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void QMqttClient::authenticationRequested(const QMqttAuthenticationProperties & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void QMqttClient::authenticationFinished(const QMqttAuthenticationProperties & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}
QT_WARNING_POP
