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

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

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto QCA::InfoContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA11InfoContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::InfoContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<InfoContext, qt_meta_tag_ZN3QCA11InfoContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::InfoContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11InfoContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11InfoContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA11InfoContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::InfoContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11InfoContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::InfoContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA13RandomContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::RandomContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA13RandomContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::RandomContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<RandomContext, qt_meta_tag_ZN3QCA13RandomContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::RandomContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA13RandomContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA13RandomContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA13RandomContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::RandomContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA13RandomContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::RandomContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA11HashContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::HashContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA11HashContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::HashContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<HashContext, qt_meta_tag_ZN3QCA11HashContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::HashContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11HashContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11HashContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA11HashContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::HashContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11HashContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::HashContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA13CipherContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::CipherContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA13CipherContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::CipherContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CipherContext, qt_meta_tag_ZN3QCA13CipherContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::CipherContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA13CipherContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA13CipherContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA13CipherContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::CipherContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA13CipherContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::CipherContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA10MACContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::MACContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA10MACContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::MACContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<MACContext, qt_meta_tag_ZN3QCA10MACContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::MACContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10MACContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10MACContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA10MACContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::MACContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10MACContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::MACContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA10KDFContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::KDFContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA10KDFContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::KDFContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KDFContext, qt_meta_tag_ZN3QCA10KDFContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::KDFContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10KDFContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10KDFContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA10KDFContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::KDFContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10KDFContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::KDFContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA11HKDFContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::HKDFContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA11HKDFContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::HKDFContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<HKDFContext, qt_meta_tag_ZN3QCA11HKDFContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::HKDFContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11HKDFContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11HKDFContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA11HKDFContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::HKDFContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11HKDFContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::HKDFContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA14DLGroupContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::DLGroupContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA14DLGroupContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::DLGroupContext",
        "finished",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'finished'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DLGroupContext, qt_meta_tag_ZN3QCA14DLGroupContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::DLGroupContext::staticMetaObject = { {
    QMetaObject::SuperData::link<Provider::Context::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA14DLGroupContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA14DLGroupContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA14DLGroupContextE_t>.metaTypes,
    nullptr
} };

void QCA::DLGroupContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DLGroupContext *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->finished(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DLGroupContext::*)()>(_a, &DLGroupContext::finished, 0))
            return;
    }
}

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

void *QCA::DLGroupContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA14DLGroupContextE_t>.strings))
        return static_cast<void*>(this);
    return Provider::Context::qt_metacast(_clname);
}

int QCA::DLGroupContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Provider::Context::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void QCA::DLGroupContext::finished()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN3QCA8PKeyBaseE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::PKeyBase::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA8PKeyBaseE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::PKeyBase",
        "finished",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'finished'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PKeyBase, qt_meta_tag_ZN3QCA8PKeyBaseE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::PKeyBase::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA8PKeyBaseE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA8PKeyBaseE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA8PKeyBaseE_t>.metaTypes,
    nullptr
} };

void QCA::PKeyBase::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PKeyBase *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->finished(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PKeyBase::*)()>(_a, &PKeyBase::finished, 0))
            return;
    }
}

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

void *QCA::PKeyBase::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA8PKeyBaseE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::PKeyBase::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void QCA::PKeyBase::finished()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN3QCA10RSAContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::RSAContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA10RSAContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::RSAContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<RSAContext, qt_meta_tag_ZN3QCA10RSAContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::RSAContext::staticMetaObject = { {
    QMetaObject::SuperData::link<PKeyBase::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10RSAContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10RSAContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA10RSAContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::RSAContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10RSAContextE_t>.strings))
        return static_cast<void*>(this);
    return PKeyBase::qt_metacast(_clname);
}

int QCA::RSAContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PKeyBase::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA10DSAContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::DSAContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA10DSAContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::DSAContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DSAContext, qt_meta_tag_ZN3QCA10DSAContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::DSAContext::staticMetaObject = { {
    QMetaObject::SuperData::link<PKeyBase::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10DSAContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10DSAContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA10DSAContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::DSAContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10DSAContextE_t>.strings))
        return static_cast<void*>(this);
    return PKeyBase::qt_metacast(_clname);
}

int QCA::DSAContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PKeyBase::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA9DHContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::DHContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA9DHContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::DHContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DHContext, qt_meta_tag_ZN3QCA9DHContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::DHContext::staticMetaObject = { {
    QMetaObject::SuperData::link<PKeyBase::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA9DHContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA9DHContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA9DHContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::DHContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA9DHContextE_t>.strings))
        return static_cast<void*>(this);
    return PKeyBase::qt_metacast(_clname);
}

int QCA::DHContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PKeyBase::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA11PKeyContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::PKeyContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA11PKeyContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::PKeyContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PKeyContext, qt_meta_tag_ZN3QCA11PKeyContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::PKeyContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11PKeyContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11PKeyContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA11PKeyContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::PKeyContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11PKeyContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::PKeyContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA8CertBaseE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::CertBase::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA8CertBaseE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::CertBase"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CertBase, qt_meta_tag_ZN3QCA8CertBaseE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::CertBase::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA8CertBaseE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA8CertBaseE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA8CertBaseE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::CertBase::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA8CertBaseE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::CertBase::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA11CertContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::CertContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA11CertContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::CertContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CertContext, qt_meta_tag_ZN3QCA11CertContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::CertContext::staticMetaObject = { {
    QMetaObject::SuperData::link<CertBase::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11CertContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11CertContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA11CertContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::CertContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11CertContextE_t>.strings))
        return static_cast<void*>(this);
    return CertBase::qt_metacast(_clname);
}

int QCA::CertContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CertBase::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA10CSRContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::CSRContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA10CSRContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::CSRContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CSRContext, qt_meta_tag_ZN3QCA10CSRContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::CSRContext::staticMetaObject = { {
    QMetaObject::SuperData::link<CertBase::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10CSRContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10CSRContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA10CSRContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::CSRContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10CSRContextE_t>.strings))
        return static_cast<void*>(this);
    return CertBase::qt_metacast(_clname);
}

int QCA::CSRContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CertBase::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA10CRLContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::CRLContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA10CRLContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::CRLContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CRLContext, qt_meta_tag_ZN3QCA10CRLContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::CRLContext::staticMetaObject = { {
    QMetaObject::SuperData::link<CertBase::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10CRLContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10CRLContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA10CRLContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::CRLContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10CRLContextE_t>.strings))
        return static_cast<void*>(this);
    return CertBase::qt_metacast(_clname);
}

int QCA::CRLContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = CertBase::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA21CertCollectionContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::CertCollectionContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA21CertCollectionContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::CertCollectionContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CertCollectionContext, qt_meta_tag_ZN3QCA21CertCollectionContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::CertCollectionContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA21CertCollectionContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA21CertCollectionContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA21CertCollectionContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::CertCollectionContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA21CertCollectionContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::CertCollectionContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA9CAContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::CAContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA9CAContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::CAContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CAContext, qt_meta_tag_ZN3QCA9CAContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::CAContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA9CAContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA9CAContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA9CAContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::CAContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA9CAContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::CAContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA13PKCS12ContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::PKCS12Context::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA13PKCS12ContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::PKCS12Context"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PKCS12Context, qt_meta_tag_ZN3QCA13PKCS12ContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::PKCS12Context::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA13PKCS12ContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA13PKCS12ContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA13PKCS12ContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::PKCS12Context::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA13PKCS12ContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::PKCS12Context::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA13PGPKeyContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::PGPKeyContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA13PGPKeyContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::PGPKeyContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PGPKeyContext, qt_meta_tag_ZN3QCA13PGPKeyContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::PGPKeyContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA13PGPKeyContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA13PGPKeyContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA13PGPKeyContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::PGPKeyContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA13PGPKeyContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::PGPKeyContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA20KeyStoreEntryContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::KeyStoreEntryContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA20KeyStoreEntryContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::KeyStoreEntryContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KeyStoreEntryContext, qt_meta_tag_ZN3QCA20KeyStoreEntryContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::KeyStoreEntryContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA20KeyStoreEntryContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA20KeyStoreEntryContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA20KeyStoreEntryContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::KeyStoreEntryContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA20KeyStoreEntryContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::KeyStoreEntryContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA19KeyStoreListContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::KeyStoreListContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA19KeyStoreListContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::KeyStoreListContext",
        "busyStart",
        "",
        "busyEnd",
        "updated",
        "diagnosticText",
        "str",
        "storeUpdated",
        "id"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'busyStart'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'busyEnd'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'updated'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'diagnosticText'
        QtMocHelpers::SignalData<void(const QString &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 6 },
        }}),
        // Signal 'storeUpdated'
        QtMocHelpers::SignalData<void(int)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<KeyStoreListContext, qt_meta_tag_ZN3QCA19KeyStoreListContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::KeyStoreListContext::staticMetaObject = { {
    QMetaObject::SuperData::link<Provider::Context::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA19KeyStoreListContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA19KeyStoreListContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA19KeyStoreListContextE_t>.metaTypes,
    nullptr
} };

void QCA::KeyStoreListContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<KeyStoreListContext *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->busyStart(); break;
        case 1: _t->busyEnd(); break;
        case 2: _t->updated(); break;
        case 3: _t->diagnosticText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 4: _t->storeUpdated((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (KeyStoreListContext::*)()>(_a, &KeyStoreListContext::busyStart, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (KeyStoreListContext::*)()>(_a, &KeyStoreListContext::busyEnd, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (KeyStoreListContext::*)()>(_a, &KeyStoreListContext::updated, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (KeyStoreListContext::*)(const QString & )>(_a, &KeyStoreListContext::diagnosticText, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (KeyStoreListContext::*)(int )>(_a, &KeyStoreListContext::storeUpdated, 4))
            return;
    }
}

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

void *QCA::KeyStoreListContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA19KeyStoreListContextE_t>.strings))
        return static_cast<void*>(this);
    return Provider::Context::qt_metacast(_clname);
}

int QCA::KeyStoreListContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Provider::Context::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 5;
    }
    return _id;
}

// SIGNAL 0
void QCA::KeyStoreListContext::busyStart()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void QCA::KeyStoreListContext::busyEnd()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void QCA::KeyStoreListContext::updated()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void QCA::KeyStoreListContext::diagnosticText(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void QCA::KeyStoreListContext::storeUpdated(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN3QCA17TLSSessionContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::TLSSessionContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA17TLSSessionContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::TLSSessionContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<TLSSessionContext, qt_meta_tag_ZN3QCA17TLSSessionContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::TLSSessionContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA17TLSSessionContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA17TLSSessionContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA17TLSSessionContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::TLSSessionContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA17TLSSessionContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::TLSSessionContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN3QCA10TLSContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::TLSContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA10TLSContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::TLSContext",
        "resultsReady",
        "",
        "dtlsTimeout"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'resultsReady'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'dtlsTimeout'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<TLSContext, qt_meta_tag_ZN3QCA10TLSContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::TLSContext::staticMetaObject = { {
    QMetaObject::SuperData::link<Provider::Context::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10TLSContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10TLSContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA10TLSContextE_t>.metaTypes,
    nullptr
} };

void QCA::TLSContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<TLSContext *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->resultsReady(); break;
        case 1: _t->dtlsTimeout(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (TLSContext::*)()>(_a, &TLSContext::resultsReady, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (TLSContext::*)()>(_a, &TLSContext::dtlsTimeout, 1))
            return;
    }
}

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

void *QCA::TLSContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10TLSContextE_t>.strings))
        return static_cast<void*>(this);
    return Provider::Context::qt_metacast(_clname);
}

int QCA::TLSContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Provider::Context::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 2;
    }
    return _id;
}

// SIGNAL 0
void QCA::TLSContext::resultsReady()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void QCA::TLSContext::dtlsTimeout()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}
namespace {
struct qt_meta_tag_ZN3QCA11SASLContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::SASLContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA11SASLContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::SASLContext",
        "resultsReady",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'resultsReady'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<SASLContext, qt_meta_tag_ZN3QCA11SASLContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::SASLContext::staticMetaObject = { {
    QMetaObject::SuperData::link<Provider::Context::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11SASLContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11SASLContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA11SASLContextE_t>.metaTypes,
    nullptr
} };

void QCA::SASLContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<SASLContext *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->resultsReady(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (SASLContext::*)()>(_a, &SASLContext::resultsReady, 0))
            return;
    }
}

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

void *QCA::SASLContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA11SASLContextE_t>.strings))
        return static_cast<void*>(this);
    return Provider::Context::qt_metacast(_clname);
}

int QCA::SASLContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Provider::Context::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void QCA::SASLContext::resultsReady()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN3QCA14MessageContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::MessageContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA14MessageContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::MessageContext",
        "updated",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'updated'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<MessageContext, qt_meta_tag_ZN3QCA14MessageContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::MessageContext::staticMetaObject = { {
    QMetaObject::SuperData::link<Provider::Context::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA14MessageContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA14MessageContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA14MessageContextE_t>.metaTypes,
    nullptr
} };

void QCA::MessageContext::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<MessageContext *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->updated(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (MessageContext::*)()>(_a, &MessageContext::updated, 0))
            return;
    }
}

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

void *QCA::MessageContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA14MessageContextE_t>.strings))
        return static_cast<void*>(this);
    return Provider::Context::qt_metacast(_clname);
}

int QCA::MessageContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Provider::Context::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void QCA::MessageContext::updated()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN3QCA10SMSContextE_t {};
} // unnamed namespace

template <> constexpr inline auto QCA::SMSContext::qt_create_metaobjectdata<qt_meta_tag_ZN3QCA10SMSContextE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QCA::SMSContext"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<SMSContext, qt_meta_tag_ZN3QCA10SMSContextE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QCA::SMSContext::staticMetaObject = { {
    QMetaObject::SuperData::link<BasicContext::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10SMSContextE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10SMSContextE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN3QCA10SMSContextE_t>.metaTypes,
    nullptr
} };

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

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

void *QCA::SMSContext::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN3QCA10SMSContextE_t>.strings))
        return static_cast<void*>(this);
    return BasicContext::qt_metacast(_clname);
}

int QCA::SMSContext::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = BasicContext::qt_metacall(_c, _id, _a);
    return _id;
}
QT_WARNING_POP
