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

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

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto HciManager::qt_create_metaobjectdata<qt_meta_tag_ZN10HciManagerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "HciManager",
        "encryptionChangedEvent",
        "",
        "QBluetoothAddress",
        "address",
        "wasSuccess",
        "commandCompleted",
        "opCode",
        "status",
        "data",
        "connectionComplete",
        "handle",
        "connectionUpdate",
        "QLowEnergyConnectionParameters",
        "parameters",
        "signatureResolvingKeyReceived",
        "connHandle",
        "remoteKey",
        "BluezUint128",
        "csrk",
        "_q_readNotify",
        "HciEvent",
        "EVT_INQUIRY_COMPLETE",
        "EVT_INQUIRY_RESULT",
        "EVT_CONN_COMPLETE",
        "EVT_CONN_REQUEST",
        "EVT_DISCONN_COMPLETE",
        "EVT_AUTH_COMPLETE",
        "EVT_REMOTE_NAME_REQ_COMPLETE",
        "EVT_ENCRYPT_CHANGE",
        "EVT_CHANGE_CONN_LINK_KEY_COMPLETE",
        "EVT_MASTER_LINK_KEY_COMPLETE",
        "EVT_READ_REMOTE_FEATURES_COMPLETE",
        "EVT_READ_REMOTE_VERSION_COMPLETE",
        "EVT_QOS_SETUP_COMPLETE",
        "EVT_CMD_COMPLETE",
        "EVT_CMD_STATUS",
        "EVT_HARDWARE_ERROR",
        "EVT_FLUSH_OCCURRED",
        "EVT_ROLE_CHANGE",
        "EVT_NUM_COMP_PKTS",
        "EVT_MODE_CHANGE",
        "EVT_RETURN_LINK_KEYS",
        "EVT_PIN_CODE_REQ",
        "EVT_LINK_KEY_REQ",
        "EVT_LINK_KEY_NOTIFY",
        "EVT_LOOPBACK_COMMAND",
        "EVT_DATA_BUFFER_OVERFLOW",
        "EVT_MAX_SLOTS_CHANGE",
        "EVT_READ_CLOCK_OFFSET_COMPLETE",
        "EVT_CONN_PTYPE_CHANGED",
        "EVT_QOS_VIOLATION",
        "EVT_PSCAN_REP_MODE_CHANGE",
        "EVT_FLOW_SPEC_COMPLETE",
        "EVT_INQUIRY_RESULT_WITH_RSSI",
        "EVT_READ_REMOTE_EXT_FEATURES_COMPLETE",
        "EVT_SYNC_CONN_COMPLETE",
        "EVT_SYNC_CONN_CHANGED",
        "EVT_SNIFF_SUBRATING",
        "EVT_EXTENDED_INQUIRY_RESULT",
        "EVT_ENCRYPTION_KEY_REFRESH_COMPLETE",
        "EVT_IO_CAPABILITY_REQUEST",
        "EVT_IO_CAPABILITY_RESPONSE",
        "EVT_USER_CONFIRM_REQUEST",
        "EVT_USER_PASSKEY_REQUEST",
        "EVT_REMOTE_OOB_DATA_REQUEST",
        "EVT_SIMPLE_PAIRING_COMPLETE",
        "EVT_LINK_SUPERVISION_TIMEOUT_CHANGED",
        "EVT_ENHANCED_FLUSH_COMPLETE",
        "EVT_USER_PASSKEY_NOTIFY",
        "EVT_KEYPRESS_NOTIFY",
        "EVT_REMOTE_HOST_FEATURES_NOTIFY",
        "EVT_LE_META_EVENT",
        "EVT_PHYSICAL_LINK_COMPLETE",
        "EVT_CHANNEL_SELECTED",
        "EVT_DISCONNECT_PHYSICAL_LINK_COMPLETE",
        "EVT_PHYSICAL_LINK_LOSS_EARLY_WARNING",
        "EVT_PHYSICAL_LINK_RECOVERY",
        "EVT_LOGICAL_LINK_COMPLETE",
        "EVT_DISCONNECT_LOGICAL_LINK_COMPLETE",
        "EVT_FLOW_SPEC_MODIFY_COMPLETE",
        "EVT_NUMBER_COMPLETED_BLOCKS",
        "EVT_AMP_STATUS_CHANGE",
        "EVT_TESTING",
        "EVT_VENDOR",
        "EVT_STACK_INTERNAL",
        "HciError",
        "HCI_SUCCESS",
        "HCI_UNKNOWN_COMMAND",
        "HCI_NO_CONNECTION",
        "HCI_HARDWARE_FAILURE",
        "HCI_PAGE_TIMEOUT",
        "HCI_AUTHENTICATION_FAILURE",
        "HCI_PIN_OR_KEY_MISSING",
        "HCI_MEMORY_FULL",
        "HCI_CONNECTION_TIMEOUT",
        "HCI_MAX_NUMBER_OF_CONNECTIONS",
        "HCI_MAX_NUMBER_OF_SCO_CONNECTIONS",
        "HCI_ACL_CONNECTION_EXISTS",
        "HCI_COMMAND_DISALLOWED",
        "HCI_REJECTED_LIMITED_RESOURCES",
        "HCI_REJECTED_SECURITY",
        "HCI_REJECTED_PERSONAL",
        "HCI_HOST_TIMEOUT",
        "HCI_UNSUPPORTED_FEATURE",
        "HCI_INVALID_PARAMETERS",
        "HCI_OE_USER_ENDED_CONNECTION",
        "HCI_OE_LOW_RESOURCES",
        "HCI_OE_POWER_OFF",
        "HCI_CONNECTION_TERMINATED",
        "HCI_REPEATED_ATTEMPTS",
        "HCI_PAIRING_NOT_ALLOWED",
        "HCI_UNKNOWN_LMP_PDU",
        "HCI_UNSUPPORTED_REMOTE_FEATURE",
        "HCI_SCO_OFFSET_REJECTED",
        "HCI_SCO_INTERVAL_REJECTED",
        "HCI_AIR_MODE_REJECTED",
        "HCI_INVALID_LMP_PARAMETERS",
        "HCI_UNSPECIFIED_ERROR",
        "HCI_UNSUPPORTED_LMP_PARAMETER_VALUE",
        "HCI_ROLE_CHANGE_NOT_ALLOWED",
        "HCI_LMP_RESPONSE_TIMEOUT",
        "HCI_LMP_ERROR_TRANSACTION_COLLISION",
        "HCI_LMP_PDU_NOT_ALLOWED",
        "HCI_ENCRYPTION_MODE_NOT_ACCEPTED",
        "HCI_UNIT_LINK_KEY_USED",
        "HCI_QOS_NOT_SUPPORTED",
        "HCI_INSTANT_PASSED",
        "HCI_PAIRING_NOT_SUPPORTED",
        "HCI_TRANSACTION_COLLISION",
        "HCI_QOS_UNACCEPTABLE_PARAMETER",
        "HCI_QOS_REJECTED",
        "HCI_CLASSIFICATION_NOT_SUPPORTED",
        "HCI_INSUFFICIENT_SECURITY",
        "HCI_PARAMETER_OUT_OF_RANGE",
        "HCI_ROLE_SWITCH_PENDING",
        "HCI_SLOT_VIOLATION",
        "HCI_ROLE_SWITCH_FAILED",
        "HCI_EIR_TOO_LARGE",
        "HCI_SIMPLE_PAIRING_NOT_SUPPORTED",
        "HCI_HOST_BUSY_PAIRING"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'encryptionChangedEvent'
        QtMocHelpers::SignalData<void(const QBluetoothAddress &, bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 3, 4 }, { QMetaType::Bool, 5 },
        }}),
        // Signal 'commandCompleted'
        QtMocHelpers::SignalData<void(quint16, quint8, const QByteArray &)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UShort, 7 }, { QMetaType::UChar, 8 }, { QMetaType::QByteArray, 9 },
        }}),
        // Signal 'connectionComplete'
        QtMocHelpers::SignalData<void(quint16)>(10, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UShort, 11 },
        }}),
        // Signal 'connectionUpdate'
        QtMocHelpers::SignalData<void(quint16, const QLowEnergyConnectionParameters &)>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UShort, 11 }, { 0x80000000 | 13, 14 },
        }}),
        // Signal 'signatureResolvingKeyReceived'
        QtMocHelpers::SignalData<void(quint16, bool, BluezUint128)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UShort, 16 }, { QMetaType::Bool, 17 }, { 0x80000000 | 18, 19 },
        }}),
        // Slot '_q_readNotify'
        QtMocHelpers::SlotData<void()>(20, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'HciEvent'
        QtMocHelpers::EnumData<enum HciEvent>(21, 21, QMC::EnumIsScoped).add({
            {   22, HciEvent::EVT_INQUIRY_COMPLETE },
            {   23, HciEvent::EVT_INQUIRY_RESULT },
            {   24, HciEvent::EVT_CONN_COMPLETE },
            {   25, HciEvent::EVT_CONN_REQUEST },
            {   26, HciEvent::EVT_DISCONN_COMPLETE },
            {   27, HciEvent::EVT_AUTH_COMPLETE },
            {   28, HciEvent::EVT_REMOTE_NAME_REQ_COMPLETE },
            {   29, HciEvent::EVT_ENCRYPT_CHANGE },
            {   30, HciEvent::EVT_CHANGE_CONN_LINK_KEY_COMPLETE },
            {   31, HciEvent::EVT_MASTER_LINK_KEY_COMPLETE },
            {   32, HciEvent::EVT_READ_REMOTE_FEATURES_COMPLETE },
            {   33, HciEvent::EVT_READ_REMOTE_VERSION_COMPLETE },
            {   34, HciEvent::EVT_QOS_SETUP_COMPLETE },
            {   35, HciEvent::EVT_CMD_COMPLETE },
            {   36, HciEvent::EVT_CMD_STATUS },
            {   37, HciEvent::EVT_HARDWARE_ERROR },
            {   38, HciEvent::EVT_FLUSH_OCCURRED },
            {   39, HciEvent::EVT_ROLE_CHANGE },
            {   40, HciEvent::EVT_NUM_COMP_PKTS },
            {   41, HciEvent::EVT_MODE_CHANGE },
            {   42, HciEvent::EVT_RETURN_LINK_KEYS },
            {   43, HciEvent::EVT_PIN_CODE_REQ },
            {   44, HciEvent::EVT_LINK_KEY_REQ },
            {   45, HciEvent::EVT_LINK_KEY_NOTIFY },
            {   46, HciEvent::EVT_LOOPBACK_COMMAND },
            {   47, HciEvent::EVT_DATA_BUFFER_OVERFLOW },
            {   48, HciEvent::EVT_MAX_SLOTS_CHANGE },
            {   49, HciEvent::EVT_READ_CLOCK_OFFSET_COMPLETE },
            {   50, HciEvent::EVT_CONN_PTYPE_CHANGED },
            {   51, HciEvent::EVT_QOS_VIOLATION },
            {   52, HciEvent::EVT_PSCAN_REP_MODE_CHANGE },
            {   53, HciEvent::EVT_FLOW_SPEC_COMPLETE },
            {   54, HciEvent::EVT_INQUIRY_RESULT_WITH_RSSI },
            {   55, HciEvent::EVT_READ_REMOTE_EXT_FEATURES_COMPLETE },
            {   56, HciEvent::EVT_SYNC_CONN_COMPLETE },
            {   57, HciEvent::EVT_SYNC_CONN_CHANGED },
            {   58, HciEvent::EVT_SNIFF_SUBRATING },
            {   59, HciEvent::EVT_EXTENDED_INQUIRY_RESULT },
            {   60, HciEvent::EVT_ENCRYPTION_KEY_REFRESH_COMPLETE },
            {   61, HciEvent::EVT_IO_CAPABILITY_REQUEST },
            {   62, HciEvent::EVT_IO_CAPABILITY_RESPONSE },
            {   63, HciEvent::EVT_USER_CONFIRM_REQUEST },
            {   64, HciEvent::EVT_USER_PASSKEY_REQUEST },
            {   65, HciEvent::EVT_REMOTE_OOB_DATA_REQUEST },
            {   66, HciEvent::EVT_SIMPLE_PAIRING_COMPLETE },
            {   67, HciEvent::EVT_LINK_SUPERVISION_TIMEOUT_CHANGED },
            {   68, HciEvent::EVT_ENHANCED_FLUSH_COMPLETE },
            {   69, HciEvent::EVT_USER_PASSKEY_NOTIFY },
            {   70, HciEvent::EVT_KEYPRESS_NOTIFY },
            {   71, HciEvent::EVT_REMOTE_HOST_FEATURES_NOTIFY },
            {   72, HciEvent::EVT_LE_META_EVENT },
            {   73, HciEvent::EVT_PHYSICAL_LINK_COMPLETE },
            {   74, HciEvent::EVT_CHANNEL_SELECTED },
            {   75, HciEvent::EVT_DISCONNECT_PHYSICAL_LINK_COMPLETE },
            {   76, HciEvent::EVT_PHYSICAL_LINK_LOSS_EARLY_WARNING },
            {   77, HciEvent::EVT_PHYSICAL_LINK_RECOVERY },
            {   78, HciEvent::EVT_LOGICAL_LINK_COMPLETE },
            {   79, HciEvent::EVT_DISCONNECT_LOGICAL_LINK_COMPLETE },
            {   80, HciEvent::EVT_FLOW_SPEC_MODIFY_COMPLETE },
            {   81, HciEvent::EVT_NUMBER_COMPLETED_BLOCKS },
            {   82, HciEvent::EVT_AMP_STATUS_CHANGE },
            {   83, HciEvent::EVT_TESTING },
            {   84, HciEvent::EVT_VENDOR },
            {   85, HciEvent::EVT_STACK_INTERNAL },
        }),
        // enum 'HciError'
        QtMocHelpers::EnumData<enum HciError>(86, 86, QMC::EnumIsScoped).add({
            {   87, HciError::HCI_SUCCESS },
            {   88, HciError::HCI_UNKNOWN_COMMAND },
            {   89, HciError::HCI_NO_CONNECTION },
            {   90, HciError::HCI_HARDWARE_FAILURE },
            {   91, HciError::HCI_PAGE_TIMEOUT },
            {   92, HciError::HCI_AUTHENTICATION_FAILURE },
            {   93, HciError::HCI_PIN_OR_KEY_MISSING },
            {   94, HciError::HCI_MEMORY_FULL },
            {   95, HciError::HCI_CONNECTION_TIMEOUT },
            {   96, HciError::HCI_MAX_NUMBER_OF_CONNECTIONS },
            {   97, HciError::HCI_MAX_NUMBER_OF_SCO_CONNECTIONS },
            {   98, HciError::HCI_ACL_CONNECTION_EXISTS },
            {   99, HciError::HCI_COMMAND_DISALLOWED },
            {  100, HciError::HCI_REJECTED_LIMITED_RESOURCES },
            {  101, HciError::HCI_REJECTED_SECURITY },
            {  102, HciError::HCI_REJECTED_PERSONAL },
            {  103, HciError::HCI_HOST_TIMEOUT },
            {  104, HciError::HCI_UNSUPPORTED_FEATURE },
            {  105, HciError::HCI_INVALID_PARAMETERS },
            {  106, HciError::HCI_OE_USER_ENDED_CONNECTION },
            {  107, HciError::HCI_OE_LOW_RESOURCES },
            {  108, HciError::HCI_OE_POWER_OFF },
            {  109, HciError::HCI_CONNECTION_TERMINATED },
            {  110, HciError::HCI_REPEATED_ATTEMPTS },
            {  111, HciError::HCI_PAIRING_NOT_ALLOWED },
            {  112, HciError::HCI_UNKNOWN_LMP_PDU },
            {  113, HciError::HCI_UNSUPPORTED_REMOTE_FEATURE },
            {  114, HciError::HCI_SCO_OFFSET_REJECTED },
            {  115, HciError::HCI_SCO_INTERVAL_REJECTED },
            {  116, HciError::HCI_AIR_MODE_REJECTED },
            {  117, HciError::HCI_INVALID_LMP_PARAMETERS },
            {  118, HciError::HCI_UNSPECIFIED_ERROR },
            {  119, HciError::HCI_UNSUPPORTED_LMP_PARAMETER_VALUE },
            {  120, HciError::HCI_ROLE_CHANGE_NOT_ALLOWED },
            {  121, HciError::HCI_LMP_RESPONSE_TIMEOUT },
            {  122, HciError::HCI_LMP_ERROR_TRANSACTION_COLLISION },
            {  123, HciError::HCI_LMP_PDU_NOT_ALLOWED },
            {  124, HciError::HCI_ENCRYPTION_MODE_NOT_ACCEPTED },
            {  125, HciError::HCI_UNIT_LINK_KEY_USED },
            {  126, HciError::HCI_QOS_NOT_SUPPORTED },
            {  127, HciError::HCI_INSTANT_PASSED },
            {  128, HciError::HCI_PAIRING_NOT_SUPPORTED },
            {  129, HciError::HCI_TRANSACTION_COLLISION },
            {  130, HciError::HCI_QOS_UNACCEPTABLE_PARAMETER },
            {  131, HciError::HCI_QOS_REJECTED },
            {  132, HciError::HCI_CLASSIFICATION_NOT_SUPPORTED },
            {  133, HciError::HCI_INSUFFICIENT_SECURITY },
            {  134, HciError::HCI_PARAMETER_OUT_OF_RANGE },
            {  135, HciError::HCI_ROLE_SWITCH_PENDING },
            {  136, HciError::HCI_SLOT_VIOLATION },
            {  137, HciError::HCI_ROLE_SWITCH_FAILED },
            {  138, HciError::HCI_EIR_TOO_LARGE },
            {  139, HciError::HCI_SIMPLE_PAIRING_NOT_SUPPORTED },
            {  140, HciError::HCI_HOST_BUSY_PAIRING },
        }),
    };
    return QtMocHelpers::metaObjectData<HciManager, qt_meta_tag_ZN10HciManagerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject HciManager::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10HciManagerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10HciManagerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN10HciManagerE_t>.metaTypes,
    nullptr
} };

void HciManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<HciManager *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->encryptionChangedEvent((*reinterpret_cast<std::add_pointer_t<QBluetoothAddress>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 1: _t->commandCompleted((*reinterpret_cast<std::add_pointer_t<quint16>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<quint8>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[3]))); break;
        case 2: _t->connectionComplete((*reinterpret_cast<std::add_pointer_t<quint16>>(_a[1]))); break;
        case 3: _t->connectionUpdate((*reinterpret_cast<std::add_pointer_t<quint16>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QLowEnergyConnectionParameters>>(_a[2]))); break;
        case 4: _t->signatureResolvingKeyReceived((*reinterpret_cast<std::add_pointer_t<quint16>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<BluezUint128>>(_a[3]))); break;
        case 5: _t->_q_readNotify(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 0:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QBluetoothAddress >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (HciManager::*)(const QBluetoothAddress & , bool )>(_a, &HciManager::encryptionChangedEvent, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (HciManager::*)(quint16 , quint8 , const QByteArray & )>(_a, &HciManager::commandCompleted, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (HciManager::*)(quint16 )>(_a, &HciManager::connectionComplete, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (HciManager::*)(quint16 , const QLowEnergyConnectionParameters & )>(_a, &HciManager::connectionUpdate, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (HciManager::*)(quint16 , bool , BluezUint128 )>(_a, &HciManager::signatureResolvingKeyReceived, 4))
            return;
    }
}

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

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

int HciManager::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 < 6)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 6;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 6)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 6;
    }
    return _id;
}

// SIGNAL 0
void HciManager::encryptionChangedEvent(const QBluetoothAddress & _t1, bool _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}

// SIGNAL 1
void HciManager::commandCompleted(quint16 _t1, quint8 _t2, const QByteArray & _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1, _t2, _t3);
}

// SIGNAL 2
void HciManager::connectionComplete(quint16 _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void HciManager::connectionUpdate(quint16 _t1, const QLowEnergyConnectionParameters & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1, _t2);
}

// SIGNAL 4
void HciManager::signatureResolvingKeyReceived(quint16 _t1, bool _t2, BluezUint128 _t3)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1, _t2, _t3);
}
QT_WARNING_POP
