/****************************************************************************
** Meta object code from reading C++ file 'client.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 "../../../snapd-qt/Snapd/client.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 'client.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_ZN20QSnapdConnectRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdConnectRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN18QSnapdLoginRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdLoginRequest::qt_create_metaobjectdata<qt_meta_tag_ZN18QSnapdLoginRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdLoginRequest",
        "userInformation",
        "QSnapdUserInformation*",
        "",
        "authData",
        "QSnapdAuthData*"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'userInformation'
        QtMocHelpers::MethodData<QSnapdUserInformation *()>(1, 3, QMC::AccessPublic, 0x80000000 | 2),
        // Method 'authData'
        QtMocHelpers::MethodData<QSnapdAuthData *()>(4, 3, QMC::AccessPublic, 0x80000000 | 5),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'userInformation'
        QtMocHelpers::PropertyData<QSnapdUserInformation*>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
        // property 'authData'
        QtMocHelpers::PropertyData<QSnapdAuthData*>(4, 0x80000000 | 5, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdLoginRequest, qt_meta_tag_ZN18QSnapdLoginRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdLoginRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QSnapdLoginRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18QSnapdLoginRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18QSnapdLoginRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdLoginRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdLoginRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QSnapdUserInformation* _r = _t->userInformation();
            if (_a[0]) *reinterpret_cast<QSnapdUserInformation**>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdAuthData* _r = _t->authData();
            if (_a[0]) *reinterpret_cast<QSnapdAuthData**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QSnapdUserInformation**>(_v) = _t->userInformation(); break;
        case 1: *reinterpret_cast<QSnapdAuthData**>(_v) = _t->authData(); break;
        default: break;
        }
    }
}

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

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

int QSnapdLoginRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN19QSnapdLogoutRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdLogoutRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN23QSnapdGetChangesRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetChangesRequest::qt_create_metaobjectdata<qt_meta_tag_ZN23QSnapdGetChangesRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetChangesRequest",
        "changeCount",
        "",
        "change",
        "QSnapdChange*"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'changeCount'
        QtMocHelpers::MethodData<int() const>(1, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'change'
        QtMocHelpers::MethodData<QSnapdChange *(int) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'changeCount'
        QtMocHelpers::PropertyData<int>(1, QMetaType::Int, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetChangesRequest, qt_meta_tag_ZN23QSnapdGetChangesRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetChangesRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSnapdGetChangesRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSnapdGetChangesRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QSnapdGetChangesRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetChangesRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetChangesRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { int _r = _t->changeCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdChange* _r = _t->change((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdChange**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->changeCount(); break;
        default: break;
        }
    }
}

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

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

int QSnapdGetChangesRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN22QSnapdGetChangeRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetChangeRequest::qt_create_metaobjectdata<qt_meta_tag_ZN22QSnapdGetChangeRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetChangeRequest",
        "change",
        "QSnapdChange*",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'change'
        QtMocHelpers::MethodData<QSnapdChange *() const>(1, 3, QMC::AccessPublic, 0x80000000 | 2),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetChangeRequest, qt_meta_tag_ZN22QSnapdGetChangeRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetChangeRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QSnapdGetChangeRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22QSnapdGetChangeRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22QSnapdGetChangeRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetChangeRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetChangeRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QSnapdChange* _r = _t->change();
            if (_a[0]) *reinterpret_cast<QSnapdChange**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int QSnapdGetChangeRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
}
namespace {
struct qt_meta_tag_ZN24QSnapdAbortChangeRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdAbortChangeRequest::qt_create_metaobjectdata<qt_meta_tag_ZN24QSnapdAbortChangeRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdAbortChangeRequest",
        "change",
        "QSnapdChange*",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'change'
        QtMocHelpers::MethodData<QSnapdChange *() const>(1, 3, QMC::AccessPublic, 0x80000000 | 2),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdAbortChangeRequest, qt_meta_tag_ZN24QSnapdAbortChangeRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdAbortChangeRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QSnapdAbortChangeRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QSnapdAbortChangeRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24QSnapdAbortChangeRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdAbortChangeRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdAbortChangeRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QSnapdChange* _r = _t->change();
            if (_a[0]) *reinterpret_cast<QSnapdChange**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int QSnapdAbortChangeRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
}
namespace {
struct qt_meta_tag_ZN33QSnapdGetSystemInformationRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetSystemInformationRequest::qt_create_metaobjectdata<qt_meta_tag_ZN33QSnapdGetSystemInformationRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetSystemInformationRequest",
        "systemInformation",
        "QSnapdSystemInformation*"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'systemInformation'
        QtMocHelpers::PropertyData<QSnapdSystemInformation*>(1, 0x80000000 | 2, QMC::DefaultPropertyFlags | QMC::EnumOrFlag),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetSystemInformationRequest, qt_meta_tag_ZN33QSnapdGetSystemInformationRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetSystemInformationRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33QSnapdGetSystemInformationRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33QSnapdGetSystemInformationRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN33QSnapdGetSystemInformationRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetSystemInformationRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetSystemInformationRequest *>(_o);
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QSnapdSystemInformation**>(_v) = _t->systemInformation(); break;
        default: break;
        }
    }
}

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

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

int QSnapdGetSystemInformationRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN17QSnapdListRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdListRequest::qt_create_metaobjectdata<qt_meta_tag_ZN17QSnapdListRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdListRequest",
        "snapCount",
        "",
        "snap",
        "QSnapdSnap*"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'snapCount'
        QtMocHelpers::MethodData<int() const>(1, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'snap'
        QtMocHelpers::MethodData<QSnapdSnap *(int) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'snapCount'
        QtMocHelpers::PropertyData<int>(1, QMetaType::Int, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdListRequest, qt_meta_tag_ZN17QSnapdListRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdListRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QSnapdListRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QSnapdListRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QSnapdListRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdListRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdListRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { int _r = _t->snapCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdSnap* _r = _t->snap((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdSnap**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->snapCount(); break;
        default: break;
        }
    }
}

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

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

int QSnapdListRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN21QSnapdGetSnapsRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetSnapsRequest::qt_create_metaobjectdata<qt_meta_tag_ZN21QSnapdGetSnapsRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetSnapsRequest",
        "snapCount",
        "",
        "snap",
        "QSnapdSnap*"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'snapCount'
        QtMocHelpers::MethodData<int() const>(1, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'snap'
        QtMocHelpers::MethodData<QSnapdSnap *(int) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'snapCount'
        QtMocHelpers::PropertyData<int>(1, QMetaType::Int, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetSnapsRequest, qt_meta_tag_ZN21QSnapdGetSnapsRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetSnapsRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QSnapdGetSnapsRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QSnapdGetSnapsRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QSnapdGetSnapsRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetSnapsRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetSnapsRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { int _r = _t->snapCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdSnap* _r = _t->snap((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdSnap**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->snapCount(); break;
        default: break;
        }
    }
}

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

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

int QSnapdGetSnapsRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN20QSnapdListOneRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdListOneRequest::qt_create_metaobjectdata<qt_meta_tag_ZN20QSnapdListOneRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdListOneRequest",
        "snap",
        "QSnapdSnap*",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'snap'
        QtMocHelpers::MethodData<QSnapdSnap *() const>(1, 3, QMC::AccessPublic, 0x80000000 | 2),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdListOneRequest, qt_meta_tag_ZN20QSnapdListOneRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdListOneRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QSnapdListOneRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QSnapdListOneRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20QSnapdListOneRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdListOneRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdListOneRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QSnapdSnap* _r = _t->snap();
            if (_a[0]) *reinterpret_cast<QSnapdSnap**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int QSnapdListOneRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
}
namespace {
struct qt_meta_tag_ZN20QSnapdGetSnapRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetSnapRequest::qt_create_metaobjectdata<qt_meta_tag_ZN20QSnapdGetSnapRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetSnapRequest",
        "snap",
        "QSnapdSnap*",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'snap'
        QtMocHelpers::MethodData<QSnapdSnap *() const>(1, 3, QMC::AccessPublic, 0x80000000 | 2),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetSnapRequest, qt_meta_tag_ZN20QSnapdGetSnapRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetSnapRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QSnapdGetSnapRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QSnapdGetSnapRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20QSnapdGetSnapRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetSnapRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetSnapRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QSnapdSnap* _r = _t->snap();
            if (_a[0]) *reinterpret_cast<QSnapdSnap**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int QSnapdGetSnapRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
}
namespace {
struct qt_meta_tag_ZN24QSnapdGetSnapConfRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetSnapConfRequest::qt_create_metaobjectdata<qt_meta_tag_ZN24QSnapdGetSnapConfRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetSnapConfRequest",
        "configuration",
        "QHash<QString,QVariant>*",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'configuration'
        QtMocHelpers::MethodData<QHash<QString,QVariant> *() const>(1, 3, QMC::AccessPublic, 0x80000000 | 2),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetSnapConfRequest, qt_meta_tag_ZN24QSnapdGetSnapConfRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetSnapConfRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QSnapdGetSnapConfRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QSnapdGetSnapConfRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24QSnapdGetSnapConfRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetSnapConfRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetSnapConfRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QHash<QString,QVariant>* _r = _t->configuration();
            if (_a[0]) *reinterpret_cast<QHash<QString,QVariant>**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int QSnapdGetSnapConfRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
}
namespace {
struct qt_meta_tag_ZN24QSnapdSetSnapConfRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdSetSnapConfRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20QSnapdGetAppsRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetAppsRequest::qt_create_metaobjectdata<qt_meta_tag_ZN20QSnapdGetAppsRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetAppsRequest",
        "appCount",
        "",
        "app",
        "QSnapdApp*"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'appCount'
        QtMocHelpers::MethodData<int() const>(1, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'app'
        QtMocHelpers::MethodData<QSnapdApp *(int) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'appCount'
        QtMocHelpers::PropertyData<int>(1, QMetaType::Int, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetAppsRequest, qt_meta_tag_ZN20QSnapdGetAppsRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetAppsRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QSnapdGetAppsRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QSnapdGetAppsRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20QSnapdGetAppsRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetAppsRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetAppsRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { int _r = _t->appCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdApp* _r = _t->app((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdApp**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->appCount(); break;
        default: break;
        }
    }
}

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

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

int QSnapdGetAppsRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN20QSnapdGetIconRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdGetIconRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN26QSnapdGetAssertionsRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetAssertionsRequest::qt_create_metaobjectdata<qt_meta_tag_ZN26QSnapdGetAssertionsRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetAssertionsRequest",
        "assertions",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'assertions'
        QtMocHelpers::MethodData<QStringList() const>(1, 2, QMC::AccessPublic, QMetaType::QStringList),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'assertions'
        QtMocHelpers::PropertyData<QStringList>(1, QMetaType::QStringList, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetAssertionsRequest, qt_meta_tag_ZN26QSnapdGetAssertionsRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetAssertionsRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26QSnapdGetAssertionsRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26QSnapdGetAssertionsRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26QSnapdGetAssertionsRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetAssertionsRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetAssertionsRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QStringList _r = _t->assertions();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QStringList*>(_v) = _t->assertions(); break;
        default: break;
        }
    }
}

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

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

int QSnapdGetAssertionsRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN26QSnapdAddAssertionsRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdAddAssertionsRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN27QSnapdGetConnectionsRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetConnectionsRequest::qt_create_metaobjectdata<qt_meta_tag_ZN27QSnapdGetConnectionsRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetConnectionsRequest",
        "establishedCount",
        "",
        "established",
        "QSnapdConnection*",
        "undesiredCount",
        "undesired",
        "plugCount",
        "plug",
        "QSnapdPlug*",
        "slotCount",
        "slot",
        "QSnapdSlot*"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'establishedCount'
        QtMocHelpers::MethodData<int() const>(1, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'established'
        QtMocHelpers::MethodData<QSnapdConnection *(int) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
        // Method 'undesiredCount'
        QtMocHelpers::MethodData<int() const>(5, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'undesired'
        QtMocHelpers::MethodData<QSnapdConnection *(int) const>(6, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
        // Method 'plugCount'
        QtMocHelpers::MethodData<int() const>(7, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'plug'
        QtMocHelpers::MethodData<QSnapdPlug *(int) const>(8, 2, QMC::AccessPublic, 0x80000000 | 9, {{
            { QMetaType::Int, 2 },
        }}),
        // Method 'slotCount'
        QtMocHelpers::MethodData<int() const>(10, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'slot'
        QtMocHelpers::MethodData<QSnapdSlot *(int) const>(11, 2, QMC::AccessPublic, 0x80000000 | 12, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'plugCount'
        QtMocHelpers::PropertyData<int>(7, QMetaType::Int, QMC::DefaultPropertyFlags),
        // property 'slotCount'
        QtMocHelpers::PropertyData<int>(10, QMetaType::Int, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetConnectionsRequest, qt_meta_tag_ZN27QSnapdGetConnectionsRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetConnectionsRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27QSnapdGetConnectionsRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27QSnapdGetConnectionsRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27QSnapdGetConnectionsRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetConnectionsRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetConnectionsRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { int _r = _t->establishedCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdConnection* _r = _t->established((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdConnection**>(_a[0]) = std::move(_r); }  break;
        case 2: { int _r = _t->undesiredCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 3: { QSnapdConnection* _r = _t->undesired((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdConnection**>(_a[0]) = std::move(_r); }  break;
        case 4: { int _r = _t->plugCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 5: { QSnapdPlug* _r = _t->plug((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdPlug**>(_a[0]) = std::move(_r); }  break;
        case 6: { int _r = _t->slotCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 7: { QSnapdSlot* _r = _t->slot((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdSlot**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->plugCount(); break;
        case 1: *reinterpret_cast<int*>(_v) = _t->slotCount(); break;
        default: break;
        }
    }
}

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

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

int QSnapdGetConnectionsRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 8)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 8)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 8;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN26QSnapdGetInterfacesRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetInterfacesRequest::qt_create_metaobjectdata<qt_meta_tag_ZN26QSnapdGetInterfacesRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetInterfacesRequest",
        "plugCount",
        "",
        "plug",
        "QSnapdPlug*",
        "slotCount",
        "slot",
        "QSnapdSlot*"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'plugCount'
        QtMocHelpers::MethodData<int() const>(1, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'plug'
        QtMocHelpers::MethodData<QSnapdPlug *(int) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
        // Method 'slotCount'
        QtMocHelpers::MethodData<int() const>(5, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'slot'
        QtMocHelpers::MethodData<QSnapdSlot *(int) const>(6, 2, QMC::AccessPublic, 0x80000000 | 7, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'plugCount'
        QtMocHelpers::PropertyData<int>(1, QMetaType::Int, QMC::DefaultPropertyFlags),
        // property 'slotCount'
        QtMocHelpers::PropertyData<int>(5, QMetaType::Int, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetInterfacesRequest, qt_meta_tag_ZN26QSnapdGetInterfacesRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetInterfacesRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26QSnapdGetInterfacesRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26QSnapdGetInterfacesRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26QSnapdGetInterfacesRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetInterfacesRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetInterfacesRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { int _r = _t->plugCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdPlug* _r = _t->plug((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdPlug**>(_a[0]) = std::move(_r); }  break;
        case 2: { int _r = _t->slotCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 3: { QSnapdSlot* _r = _t->slot((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdSlot**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->plugCount(); break;
        case 1: *reinterpret_cast<int*>(_v) = _t->slotCount(); break;
        default: break;
        }
    }
}

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

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

int QSnapdGetInterfacesRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 4)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 4;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 4)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 4;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN27QSnapdGetInterfaces2RequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetInterfaces2Request::qt_create_metaobjectdata<qt_meta_tag_ZN27QSnapdGetInterfaces2RequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetInterfaces2Request",
        "interfaceCount",
        "",
        "interface",
        "QSnapdInterface*"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'interfaceCount'
        QtMocHelpers::MethodData<int() const>(1, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'interface'
        QtMocHelpers::MethodData<QSnapdInterface *(int) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'interfaceCount'
        QtMocHelpers::PropertyData<int>(1, QMetaType::Int, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetInterfaces2Request, qt_meta_tag_ZN27QSnapdGetInterfaces2RequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetInterfaces2Request::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27QSnapdGetInterfaces2RequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27QSnapdGetInterfaces2RequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27QSnapdGetInterfaces2RequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetInterfaces2Request::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetInterfaces2Request *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { int _r = _t->interfaceCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdInterface* _r = _t->interface((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdInterface**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->interfaceCount(); break;
        default: break;
        }
    }
}

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

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

int QSnapdGetInterfaces2Request::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN29QSnapdConnectInterfaceRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdConnectInterfaceRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN32QSnapdDisconnectInterfaceRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdDisconnectInterfaceRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN17QSnapdFindRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdFindRequest::qt_create_metaobjectdata<qt_meta_tag_ZN17QSnapdFindRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdFindRequest",
        "snapCount",
        "",
        "snap",
        "QSnapdSnap*",
        "suggestedCurrency"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'snapCount'
        QtMocHelpers::MethodData<int() const>(1, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'snap'
        QtMocHelpers::MethodData<QSnapdSnap *(int) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'snapCount'
        QtMocHelpers::PropertyData<int>(1, QMetaType::Int, QMC::DefaultPropertyFlags),
        // property 'suggestedCurrency'
        QtMocHelpers::PropertyData<QString>(5, QMetaType::QString, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdFindRequest, qt_meta_tag_ZN17QSnapdFindRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdFindRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QSnapdFindRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17QSnapdFindRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17QSnapdFindRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdFindRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdFindRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { int _r = _t->snapCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdSnap* _r = _t->snap((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdSnap**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->snapCount(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->suggestedCurrency(); break;
        default: break;
        }
    }
}

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

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

int QSnapdFindRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN28QSnapdFindRefreshableRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdFindRefreshableRequest::qt_create_metaobjectdata<qt_meta_tag_ZN28QSnapdFindRefreshableRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdFindRefreshableRequest",
        "snapCount",
        "",
        "snap",
        "QSnapdSnap*"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'snapCount'
        QtMocHelpers::MethodData<int() const>(1, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'snap'
        QtMocHelpers::MethodData<QSnapdSnap *(int) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'snapCount'
        QtMocHelpers::PropertyData<int>(1, QMetaType::Int, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdFindRefreshableRequest, qt_meta_tag_ZN28QSnapdFindRefreshableRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdFindRefreshableRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QSnapdFindRefreshableRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28QSnapdFindRefreshableRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN28QSnapdFindRefreshableRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdFindRefreshableRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdFindRefreshableRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { int _r = _t->snapCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdSnap* _r = _t->snap((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdSnap**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->snapCount(); break;
        default: break;
        }
    }
}

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

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

int QSnapdFindRefreshableRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN20QSnapdInstallRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdInstallRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN16QSnapdTryRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdTryRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20QSnapdRefreshRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdRefreshRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN23QSnapdRefreshAllRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdRefreshAllRequest::qt_create_metaobjectdata<qt_meta_tag_ZN23QSnapdRefreshAllRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdRefreshAllRequest",
        "snapNames",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'snapNames'
        QtMocHelpers::MethodData<QStringList() const>(1, 2, QMC::AccessPublic, QMetaType::QStringList),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'snapNames'
        QtMocHelpers::PropertyData<QStringList>(1, QMetaType::QStringList, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdRefreshAllRequest, qt_meta_tag_ZN23QSnapdRefreshAllRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdRefreshAllRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSnapdRefreshAllRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSnapdRefreshAllRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QSnapdRefreshAllRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdRefreshAllRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdRefreshAllRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QStringList _r = _t->snapNames();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QStringList*>(_v) = _t->snapNames(); break;
        default: break;
        }
    }
}

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

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

int QSnapdRefreshAllRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN19QSnapdRemoveRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdRemoveRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN19QSnapdEnableRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdEnableRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20QSnapdDisableRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdDisableRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN26QSnapdSwitchChannelRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdSwitchChannelRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN21QSnapdCheckBuyRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdCheckBuyRequest::qt_create_metaobjectdata<qt_meta_tag_ZN21QSnapdCheckBuyRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdCheckBuyRequest",
        "canBuy",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'canBuy'
        QtMocHelpers::MethodData<bool() const>(1, 2, QMC::AccessPublic, QMetaType::Bool),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'canBuy'
        QtMocHelpers::PropertyData<bool>(1, QMetaType::Bool, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdCheckBuyRequest, qt_meta_tag_ZN21QSnapdCheckBuyRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdCheckBuyRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QSnapdCheckBuyRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QSnapdCheckBuyRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QSnapdCheckBuyRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdCheckBuyRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdCheckBuyRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { bool _r = _t->canBuy();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->canBuy(); break;
        default: break;
        }
    }
}

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

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

int QSnapdCheckBuyRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN16QSnapdBuyRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdBuyRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN23QSnapdCreateUserRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdCreateUserRequest::qt_create_metaobjectdata<qt_meta_tag_ZN23QSnapdCreateUserRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdCreateUserRequest",
        "userInformation",
        "QSnapdUserInformation*",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'userInformation'
        QtMocHelpers::MethodData<QSnapdUserInformation *() const>(1, 3, QMC::AccessPublic, 0x80000000 | 2),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdCreateUserRequest, qt_meta_tag_ZN23QSnapdCreateUserRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdCreateUserRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSnapdCreateUserRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSnapdCreateUserRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QSnapdCreateUserRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdCreateUserRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdCreateUserRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QSnapdUserInformation* _r = _t->userInformation();
            if (_a[0]) *reinterpret_cast<QSnapdUserInformation**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int QSnapdCreateUserRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
}
namespace {
struct qt_meta_tag_ZN24QSnapdCreateUsersRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdCreateUsersRequest::qt_create_metaobjectdata<qt_meta_tag_ZN24QSnapdCreateUsersRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdCreateUsersRequest",
        "userInformationCount",
        "",
        "userInformation",
        "QSnapdUserInformation*"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'userInformationCount'
        QtMocHelpers::MethodData<int() const>(1, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'userInformation'
        QtMocHelpers::MethodData<QSnapdUserInformation *(int) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'userInformationCount'
        QtMocHelpers::PropertyData<int>(1, QMetaType::Int, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdCreateUsersRequest, qt_meta_tag_ZN24QSnapdCreateUsersRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdCreateUsersRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QSnapdCreateUsersRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QSnapdCreateUsersRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24QSnapdCreateUsersRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdCreateUsersRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdCreateUsersRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { int _r = _t->userInformationCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdUserInformation* _r = _t->userInformation((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdUserInformation**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->userInformationCount(); break;
        default: break;
        }
    }
}

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

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

int QSnapdCreateUsersRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN21QSnapdGetUsersRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetUsersRequest::qt_create_metaobjectdata<qt_meta_tag_ZN21QSnapdGetUsersRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetUsersRequest",
        "userInformationCount",
        "",
        "userInformation",
        "QSnapdUserInformation*"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'userInformationCount'
        QtMocHelpers::MethodData<int() const>(1, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'userInformation'
        QtMocHelpers::MethodData<QSnapdUserInformation *(int) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'userInformationCount'
        QtMocHelpers::PropertyData<int>(1, QMetaType::Int, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetUsersRequest, qt_meta_tag_ZN21QSnapdGetUsersRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetUsersRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QSnapdGetUsersRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QSnapdGetUsersRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QSnapdGetUsersRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetUsersRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetUsersRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { int _r = _t->userInformationCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdUserInformation* _r = _t->userInformation((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdUserInformation**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->userInformationCount(); break;
        default: break;
        }
    }
}

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

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

int QSnapdGetUsersRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN24QSnapdGetSectionsRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetSectionsRequest::qt_create_metaobjectdata<qt_meta_tag_ZN24QSnapdGetSectionsRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetSectionsRequest",
        "sections",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'sections'
        QtMocHelpers::MethodData<QStringList() const>(1, 2, QMC::AccessPublic, QMetaType::QStringList),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetSectionsRequest, qt_meta_tag_ZN24QSnapdGetSectionsRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetSectionsRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QSnapdGetSectionsRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QSnapdGetSectionsRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24QSnapdGetSectionsRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetSectionsRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetSectionsRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QStringList _r = _t->sections();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int QSnapdGetSectionsRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
}
namespace {
struct qt_meta_tag_ZN26QSnapdGetCategoriesRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetCategoriesRequest::qt_create_metaobjectdata<qt_meta_tag_ZN26QSnapdGetCategoriesRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetCategoriesRequest",
        "categoryCount",
        "",
        "category",
        "QSnapdCategoryDetails*"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'categoryCount'
        QtMocHelpers::MethodData<int() const>(1, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'category'
        QtMocHelpers::MethodData<QSnapdCategoryDetails *(int) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetCategoriesRequest, qt_meta_tag_ZN26QSnapdGetCategoriesRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetCategoriesRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26QSnapdGetCategoriesRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26QSnapdGetCategoriesRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26QSnapdGetCategoriesRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetCategoriesRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetCategoriesRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { int _r = _t->categoryCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdCategoryDetails* _r = _t->category((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdCategoryDetails**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int QSnapdGetCategoriesRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
}
namespace {
struct qt_meta_tag_ZN23QSnapdGetAliasesRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetAliasesRequest::qt_create_metaobjectdata<qt_meta_tag_ZN23QSnapdGetAliasesRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetAliasesRequest",
        "aliasCount",
        "",
        "alias",
        "QSnapdAlias*"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'aliasCount'
        QtMocHelpers::MethodData<int() const>(1, 2, QMC::AccessPublic, QMetaType::Int),
        // Method 'alias'
        QtMocHelpers::MethodData<QSnapdAlias *(int) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'aliasCount'
        QtMocHelpers::PropertyData<int>(1, QMetaType::Int, QMC::DefaultPropertyFlags),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetAliasesRequest, qt_meta_tag_ZN23QSnapdGetAliasesRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetAliasesRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSnapdGetAliasesRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSnapdGetAliasesRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QSnapdGetAliasesRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetAliasesRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetAliasesRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { int _r = _t->aliasCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdAlias* _r = _t->alias((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdAlias**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->aliasCount(); break;
        default: break;
        }
    }
}

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

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

int QSnapdGetAliasesRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN18QSnapdAliasRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdAliasRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20QSnapdUnaliasRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdUnaliasRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN19QSnapdPreferRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdPreferRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN26QSnapdEnableAliasesRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdEnableAliasesRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN27QSnapdDisableAliasesRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdDisableAliasesRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN25QSnapdResetAliasesRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdResetAliasesRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN23QSnapdRunSnapCtlRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdRunSnapCtlRequest::qt_create_metaobjectdata<qt_meta_tag_ZN23QSnapdRunSnapCtlRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdRunSnapCtlRequest",
        "stdout",
        "",
        "stderr",
        "exitCode"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'stdout'
        QtMocHelpers::MethodData<QString() const>(1, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'stderr'
        QtMocHelpers::MethodData<QString() const>(3, 2, QMC::AccessPublic, QMetaType::QString),
        // Method 'exitCode'
        QtMocHelpers::MethodData<int() const>(4, 2, QMC::AccessPublic, QMetaType::Int),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdRunSnapCtlRequest, qt_meta_tag_ZN23QSnapdRunSnapCtlRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdRunSnapCtlRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSnapdRunSnapCtlRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23QSnapdRunSnapCtlRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23QSnapdRunSnapCtlRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdRunSnapCtlRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdRunSnapCtlRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->stdout();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 1: { QString _r = _t->stderr();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 2: { int _r = _t->exitCode();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int QSnapdRunSnapCtlRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 3;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN21QSnapdDownloadRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdDownloadRequest::qt_create_metaobjectdata<qt_meta_tag_ZN21QSnapdDownloadRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdDownloadRequest",
        "data",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'data'
        QtMocHelpers::MethodData<QByteArray() const>(1, 2, QMC::AccessPublic, QMetaType::QByteArray),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdDownloadRequest, qt_meta_tag_ZN21QSnapdDownloadRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdDownloadRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QSnapdDownloadRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN21QSnapdDownloadRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN21QSnapdDownloadRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdDownloadRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdDownloadRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QByteArray _r = _t->data();
            if (_a[0]) *reinterpret_cast<QByteArray*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int QSnapdDownloadRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
}
namespace {
struct qt_meta_tag_ZN24QSnapdCheckThemesRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdCheckThemesRequest::qt_create_metaobjectdata<qt_meta_tag_ZN24QSnapdCheckThemesRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdCheckThemesRequest",
        "gtkThemeStatus",
        "ThemeStatus",
        "",
        "name",
        "iconThemeStatus",
        "soundThemeStatus",
        "ThemeInstalled",
        "ThemeAvailable",
        "ThemeUnavailable"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'gtkThemeStatus'
        QtMocHelpers::MethodData<enum ThemeStatus(const QString &) const>(1, 3, QMC::AccessPublic, 0x80000000 | 2, {{
            { QMetaType::QString, 4 },
        }}),
        // Method 'iconThemeStatus'
        QtMocHelpers::MethodData<enum ThemeStatus(const QString &) const>(5, 3, QMC::AccessPublic, 0x80000000 | 2, {{
            { QMetaType::QString, 4 },
        }}),
        // Method 'soundThemeStatus'
        QtMocHelpers::MethodData<enum ThemeStatus(const QString &) const>(6, 3, QMC::AccessPublic, 0x80000000 | 2, {{
            { QMetaType::QString, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'ThemeStatus'
        QtMocHelpers::EnumData<enum ThemeStatus>(2, 2, QMC::EnumFlags{}).add({
            {    7, ThemeStatus::ThemeInstalled },
            {    8, ThemeStatus::ThemeAvailable },
            {    9, ThemeStatus::ThemeUnavailable },
        }),
    };
    return QtMocHelpers::metaObjectData<QSnapdCheckThemesRequest, qt_meta_tag_ZN24QSnapdCheckThemesRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdCheckThemesRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QSnapdCheckThemesRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24QSnapdCheckThemesRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24QSnapdCheckThemesRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdCheckThemesRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdCheckThemesRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { enum ThemeStatus _r = _t->gtkThemeStatus((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<enum ThemeStatus*>(_a[0]) = std::move(_r); }  break;
        case 1: { enum ThemeStatus _r = _t->iconThemeStatus((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<enum ThemeStatus*>(_a[0]) = std::move(_r); }  break;
        case 2: { enum ThemeStatus _r = _t->soundThemeStatus((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<enum ThemeStatus*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int QSnapdCheckThemesRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 3)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 3)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 3;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN26QSnapdInstallThemesRequestE_t {};
} // unnamed namespace

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

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

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

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

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

int QSnapdInstallThemesRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN20QSnapdNoticesRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdNoticesRequest::qt_create_metaobjectdata<qt_meta_tag_ZN20QSnapdNoticesRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdNoticesRequest",
        "noticesCount",
        "",
        "getNotice",
        "QSnapdNotice*",
        "timeout",
        "sinceFilterSet",
        "sinceFilter",
        "userIdFilter",
        "usersFilter",
        "keysFilter",
        "typesFilter",
        "sinceNanosecondsFilter"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'noticesCount'
        QtMocHelpers::MethodData<uint() const>(1, 2, QMC::AccessPublic, QMetaType::UInt),
        // Method 'getNotice'
        QtMocHelpers::MethodData<QSnapdNotice *(quint64) const>(3, 2, QMC::AccessPublic, 0x80000000 | 4, {{
            { QMetaType::ULongLong, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'timeout'
        QtMocHelpers::PropertyData<qint64>(5, QMetaType::LongLong, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'sinceFilterSet'
        QtMocHelpers::PropertyData<bool>(6, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'sinceFilter'
        QtMocHelpers::PropertyData<QDateTime>(7, QMetaType::QDateTime, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'userIdFilter'
        QtMocHelpers::PropertyData<QString>(8, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'usersFilter'
        QtMocHelpers::PropertyData<QString>(9, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'keysFilter'
        QtMocHelpers::PropertyData<QString>(10, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'typesFilter'
        QtMocHelpers::PropertyData<QString>(11, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
        // property 'sinceNanosecondsFilter'
        QtMocHelpers::PropertyData<qint32>(12, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdNoticesRequest, qt_meta_tag_ZN20QSnapdNoticesRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdNoticesRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QSnapdNoticesRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20QSnapdNoticesRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20QSnapdNoticesRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdNoticesRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdNoticesRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { uint _r = _t->noticesCount();
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdNotice* _r = _t->getNotice((*reinterpret_cast<std::add_pointer_t<quint64>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdNotice**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<qint64*>(_v) = _t->timeout; break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->sinceFilterSet; break;
        case 2: *reinterpret_cast<QDateTime*>(_v) = _t->sinceFilter; break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->userIdFilter; break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->usersFilter; break;
        case 5: *reinterpret_cast<QString*>(_v) = _t->keysFilter; break;
        case 6: *reinterpret_cast<QString*>(_v) = _t->typesFilter; break;
        case 7: *reinterpret_cast<qint32*>(_v) = _t->sinceNanosecondsFilter; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->timeout, *reinterpret_cast<qint64*>(_v)); break;
        case 1: QtMocHelpers::setProperty(_t->sinceFilterSet, *reinterpret_cast<bool*>(_v)); break;
        case 2: QtMocHelpers::setProperty(_t->sinceFilter, *reinterpret_cast<QDateTime*>(_v)); break;
        case 3: QtMocHelpers::setProperty(_t->userIdFilter, *reinterpret_cast<QString*>(_v)); break;
        case 4: QtMocHelpers::setProperty(_t->usersFilter, *reinterpret_cast<QString*>(_v)); break;
        case 5: QtMocHelpers::setProperty(_t->keysFilter, *reinterpret_cast<QString*>(_v)); break;
        case 6: QtMocHelpers::setProperty(_t->typesFilter, *reinterpret_cast<QString*>(_v)); break;
        case 7: QtMocHelpers::setProperty(_t->sinceNanosecondsFilter, *reinterpret_cast<qint32*>(_v)); break;
        default: break;
        }
    }
}

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

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

int QSnapdNoticesRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    return _id;
}
namespace {
struct qt_meta_tag_ZN30QSnapdGetModelAssertionRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetModelAssertionRequest::qt_create_metaobjectdata<qt_meta_tag_ZN30QSnapdGetModelAssertionRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetModelAssertionRequest",
        "modelAssertion",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'modelAssertion'
        QtMocHelpers::MethodData<QString() const>(1, 2, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetModelAssertionRequest, qt_meta_tag_ZN30QSnapdGetModelAssertionRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetModelAssertionRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN30QSnapdGetModelAssertionRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN30QSnapdGetModelAssertionRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN30QSnapdGetModelAssertionRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetModelAssertionRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetModelAssertionRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->modelAssertion();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int QSnapdGetModelAssertionRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
}
namespace {
struct qt_meta_tag_ZN31QSnapdGetSerialAssertionRequestE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdGetSerialAssertionRequest::qt_create_metaobjectdata<qt_meta_tag_ZN31QSnapdGetSerialAssertionRequestE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdGetSerialAssertionRequest",
        "serialAssertion",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'serialAssertion'
        QtMocHelpers::MethodData<QString() const>(1, 2, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<QSnapdGetSerialAssertionRequest, qt_meta_tag_ZN31QSnapdGetSerialAssertionRequestE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdGetSerialAssertionRequest::staticMetaObject = { {
    QMetaObject::SuperData::link<QSnapdRequest::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31QSnapdGetSerialAssertionRequestE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31QSnapdGetSerialAssertionRequestE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN31QSnapdGetSerialAssertionRequestE_t>.metaTypes,
    nullptr
} };

void QSnapdGetSerialAssertionRequest::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdGetSerialAssertionRequest *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->serialAssertion();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
}

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

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

int QSnapdGetSerialAssertionRequest::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSnapdRequest::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;
}
namespace {
struct qt_meta_tag_ZN12QSnapdClientE_t {};
} // unnamed namespace

template <> constexpr inline auto QSnapdClient::qt_create_metaobjectdata<qt_meta_tag_ZN12QSnapdClientE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "QSnapdClient",
        "connect",
        "QSnapdConnectRequest*",
        "Q_DECL_DEPRECATED",
        "login",
        "QSnapdLoginRequest*",
        "",
        "email",
        "password",
        "otp",
        "logout",
        "QSnapdLogoutRequest*",
        "id",
        "setSocketPath",
        "socketPath",
        "setUserAgent",
        "userAgent",
        "setAllowInteraction",
        "allowInteraction",
        "maintenance",
        "QSnapdMaintenance*",
        "setAuthData",
        "QSnapdAuthData*",
        "authData",
        "getChanges",
        "QSnapdGetChangesRequest*",
        "ChangeFilter",
        "filter",
        "snapName",
        "getChange",
        "QSnapdGetChangeRequest*",
        "abortChange",
        "QSnapdAbortChangeRequest*",
        "getSystemInformation",
        "QSnapdGetSystemInformationRequest*",
        "getSnaps",
        "QSnapdGetSnapsRequest*",
        "GetSnapsFlags",
        "flags",
        "snaps",
        "snap",
        "getSnap",
        "QSnapdGetSnapRequest*",
        "name",
        "getSnapConf",
        "QSnapdGetSnapConfRequest*",
        "keys",
        "setSnapConf",
        "QSnapdSetSnapConfRequest*",
        "QHash<QString,QVariant>",
        "configuration",
        "getApps",
        "QSnapdGetAppsRequest*",
        "GetAppsFlags",
        "getIcon",
        "QSnapdGetIconRequest*",
        "getAssertions",
        "QSnapdGetAssertionsRequest*",
        "type",
        "addAssertions",
        "QSnapdAddAssertionsRequest*",
        "assertions",
        "getConnections",
        "QSnapdGetConnectionsRequest*",
        "GetConnectionsFlags",
        "interface",
        "getInterfaces",
        "QSnapdGetInterfacesRequest*",
        "getInterfaces2",
        "QSnapdGetInterfaces2Request*",
        "InterfaceFlags",
        "names",
        "connectInterface",
        "QSnapdConnectInterfaceRequest*",
        "plug_snap",
        "plug_name",
        "slot_snap",
        "slot_name",
        "disconnectInterface",
        "QSnapdDisconnectInterfaceRequest*",
        "find",
        "QSnapdFindRequest*",
        "query",
        "FindFlags",
        "findCategory",
        "category",
        "findRefreshable",
        "QSnapdFindRefreshableRequest*",
        "install",
        "QSnapdInstallRequest*",
        "channel",
        "revision",
        "InstallFlags",
        "QIODevice*",
        "ioDevice",
        "trySnap",
        "QSnapdTryRequest*",
        "path",
        "refresh",
        "QSnapdRefreshRequest*",
        "refreshAll",
        "QSnapdRefreshAllRequest*",
        "remove",
        "QSnapdRemoveRequest*",
        "RemoveFlags",
        "enable",
        "QSnapdEnableRequest*",
        "disable",
        "QSnapdDisableRequest*",
        "switchChannel",
        "QSnapdSwitchChannelRequest*",
        "checkBuy",
        "QSnapdCheckBuyRequest*",
        "buy",
        "QSnapdBuyRequest*",
        "amount",
        "currency",
        "createUser",
        "QSnapdCreateUserRequest*",
        "CreateUserFlags",
        "createUsers",
        "QSnapdCreateUsersRequest*",
        "getUsers",
        "QSnapdGetUsersRequest*",
        "getCategories",
        "QSnapdGetCategoriesRequest*",
        "getAliases",
        "QSnapdGetAliasesRequest*",
        "alias",
        "QSnapdAliasRequest*",
        "app",
        "unalias",
        "QSnapdUnaliasRequest*",
        "prefer",
        "QSnapdPreferRequest*",
        "enableAliases",
        "QSnapdEnableAliasesRequest*",
        "aliases",
        "disableAliases",
        "QSnapdDisableAliasesRequest*",
        "resetAliases",
        "QSnapdResetAliasesRequest*",
        "runSnapCtl",
        "QSnapdRunSnapCtlRequest*",
        "contextId",
        "args",
        "download",
        "QSnapdDownloadRequest*",
        "checkThemes",
        "QSnapdCheckThemesRequest*",
        "gtkThemeNames",
        "iconThemeNames",
        "soundThemeNames",
        "installThemes",
        "QSnapdInstallThemesRequest*",
        "getNotices",
        "QSnapdNoticesRequest*",
        "getModelAssertion",
        "QSnapdGetModelAssertionRequest*",
        "getSerialAssertion",
        "QSnapdGetSerialAssertionRequest*",
        "FilterAll",
        "FilterInProgress",
        "FilterReady",
        "GetConnectionsFlag",
        "SelectAll",
        "FindFlag",
        "None",
        "MatchName",
        "SelectPrivate",
        "ScopeWide",
        "MatchCommonId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'connect'
        QtMocHelpers::MethodData<QSnapdConnectRequest *()>(1, 3, QMC::AccessPublic, 0x80000000 | 2),
        // Method 'login'
        QtMocHelpers::MethodData<QSnapdLoginRequest *(const QString &, const QString &)>(4, 6, QMC::AccessPublic, 0x80000000 | 5, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 8 },
        }}),
        // Method 'login'
        QtMocHelpers::MethodData<QSnapdLoginRequest *(const QString &, const QString &, const QString &)>(4, 6, QMC::AccessPublic, 0x80000000 | 5, {{
            { QMetaType::QString, 7 }, { QMetaType::QString, 8 }, { QMetaType::QString, 9 },
        }}),
        // Method 'logout'
        QtMocHelpers::MethodData<QSnapdLogoutRequest *(qint64)>(10, 6, QMC::AccessPublic, 0x80000000 | 11, {{
            { QMetaType::LongLong, 12 },
        }}),
        // Method 'setSocketPath'
        QtMocHelpers::MethodData<void(const QString &)>(13, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 14 },
        }}),
        // Method 'socketPath'
        QtMocHelpers::MethodData<QString() const>(14, 6, QMC::AccessPublic, QMetaType::QString),
        // Method 'setUserAgent'
        QtMocHelpers::MethodData<void(const QString &)>(15, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 16 },
        }}),
        // Method 'userAgent'
        QtMocHelpers::MethodData<QString() const>(16, 6, QMC::AccessPublic, QMetaType::QString),
        // Method 'setAllowInteraction'
        QtMocHelpers::MethodData<void(bool)>(17, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 18 },
        }}),
        // Method 'allowInteraction'
        QtMocHelpers::MethodData<bool() const>(18, 6, QMC::AccessPublic, QMetaType::Bool),
        // Method 'maintenance'
        QtMocHelpers::MethodData<QSnapdMaintenance *() const>(19, 6, QMC::AccessPublic, 0x80000000 | 20),
        // Method 'setAuthData'
        QtMocHelpers::MethodData<void(QSnapdAuthData *)>(21, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 23 },
        }}),
        // Method 'authData'
        QtMocHelpers::MethodData<QSnapdAuthData *()>(23, 6, QMC::AccessPublic, 0x80000000 | 22),
        // Method 'getChanges'
        QtMocHelpers::MethodData<QSnapdGetChangesRequest *()>(24, 6, QMC::AccessPublic, 0x80000000 | 25),
        // Method 'getChanges'
        QtMocHelpers::MethodData<QSnapdGetChangesRequest *(enum ChangeFilter)>(24, 6, QMC::AccessPublic, 0x80000000 | 25, {{
            { 0x80000000 | 26, 27 },
        }}),
        // Method 'getChanges'
        QtMocHelpers::MethodData<QSnapdGetChangesRequest *(const QString &)>(24, 6, QMC::AccessPublic, 0x80000000 | 25, {{
            { QMetaType::QString, 28 },
        }}),
        // Method 'getChanges'
        QtMocHelpers::MethodData<QSnapdGetChangesRequest *(enum ChangeFilter, const QString &)>(24, 6, QMC::AccessPublic, 0x80000000 | 25, {{
            { 0x80000000 | 26, 27 }, { QMetaType::QString, 28 },
        }}),
        // Method 'getChange'
        QtMocHelpers::MethodData<QSnapdGetChangeRequest *(const QString &)>(29, 6, QMC::AccessPublic, 0x80000000 | 30, {{
            { QMetaType::QString, 12 },
        }}),
        // Method 'abortChange'
        QtMocHelpers::MethodData<QSnapdAbortChangeRequest *(const QString &)>(31, 6, QMC::AccessPublic, 0x80000000 | 32, {{
            { QMetaType::QString, 12 },
        }}),
        // Method 'getSystemInformation'
        QtMocHelpers::MethodData<QSnapdGetSystemInformationRequest *()>(33, 6, QMC::AccessPublic, 0x80000000 | 34),
        // Method 'getSnaps'
        QtMocHelpers::MethodData<QSnapdGetSnapsRequest *(GetSnapsFlags, const QStringList &)>(35, 6, QMC::AccessPublic, 0x80000000 | 36, {{
            { 0x80000000 | 37, 38 }, { QMetaType::QStringList, 39 },
        }}),
        // Method 'getSnaps'
        QtMocHelpers::MethodData<QSnapdGetSnapsRequest *(GetSnapsFlags, const QString &)>(35, 6, QMC::AccessPublic, 0x80000000 | 36, {{
            { 0x80000000 | 37, 38 }, { QMetaType::QString, 40 },
        }}),
        // Method 'getSnaps'
        QtMocHelpers::MethodData<QSnapdGetSnapsRequest *(const QStringList &)>(35, 6, QMC::AccessPublic, 0x80000000 | 36, {{
            { QMetaType::QStringList, 39 },
        }}),
        // Method 'getSnaps'
        QtMocHelpers::MethodData<QSnapdGetSnapsRequest *(const QString &)>(35, 6, QMC::AccessPublic, 0x80000000 | 36, {{
            { QMetaType::QString, 40 },
        }}),
        // Method 'getSnaps'
        QtMocHelpers::MethodData<QSnapdGetSnapsRequest *()>(35, 6, QMC::AccessPublic, 0x80000000 | 36),
        // Method 'getSnap'
        QtMocHelpers::MethodData<QSnapdGetSnapRequest *(const QString &)>(41, 6, QMC::AccessPublic, 0x80000000 | 42, {{
            { QMetaType::QString, 43 },
        }}),
        // Method 'getSnapConf'
        QtMocHelpers::MethodData<QSnapdGetSnapConfRequest *(const QString &)>(44, 6, QMC::AccessPublic, 0x80000000 | 45, {{
            { QMetaType::QString, 43 },
        }}),
        // Method 'getSnapConf'
        QtMocHelpers::MethodData<QSnapdGetSnapConfRequest *(const QString &, const QStringList &)>(44, 6, QMC::AccessPublic, 0x80000000 | 45, {{
            { QMetaType::QString, 43 }, { QMetaType::QStringList, 46 },
        }}),
        // Method 'setSnapConf'
        QtMocHelpers::MethodData<QSnapdSetSnapConfRequest *(const QString &, const QHash<QString,QVariant> &)>(47, 6, QMC::AccessPublic, 0x80000000 | 48, {{
            { QMetaType::QString, 43 }, { 0x80000000 | 49, 50 },
        }}),
        // Method 'getApps'
        QtMocHelpers::MethodData<QSnapdGetAppsRequest *()>(51, 6, QMC::AccessPublic, 0x80000000 | 52),
        // Method 'getApps'
        QtMocHelpers::MethodData<QSnapdGetAppsRequest *(GetAppsFlags)>(51, 6, QMC::AccessPublic, 0x80000000 | 52, {{
            { 0x80000000 | 53, 38 },
        }}),
        // Method 'getApps'
        QtMocHelpers::MethodData<QSnapdGetAppsRequest *(GetAppsFlags, const QStringList &)>(51, 6, QMC::AccessPublic, 0x80000000 | 52, {{
            { 0x80000000 | 53, 38 }, { QMetaType::QStringList, 39 },
        }}),
        // Method 'getApps'
        QtMocHelpers::MethodData<QSnapdGetAppsRequest *(GetAppsFlags, const QString &)>(51, 6, QMC::AccessPublic, 0x80000000 | 52, {{
            { 0x80000000 | 53, 38 }, { QMetaType::QString, 40 },
        }}),
        // Method 'getApps'
        QtMocHelpers::MethodData<QSnapdGetAppsRequest *(const QStringList &)>(51, 6, QMC::AccessPublic, 0x80000000 | 52, {{
            { QMetaType::QStringList, 39 },
        }}),
        // Method 'getApps'
        QtMocHelpers::MethodData<QSnapdGetAppsRequest *(const QString &)>(51, 6, QMC::AccessPublic, 0x80000000 | 52, {{
            { QMetaType::QString, 40 },
        }}),
        // Method 'getIcon'
        QtMocHelpers::MethodData<QSnapdGetIconRequest *(const QString &)>(54, 6, QMC::AccessPublic, 0x80000000 | 55, {{
            { QMetaType::QString, 43 },
        }}),
        // Method 'getAssertions'
        QtMocHelpers::MethodData<QSnapdGetAssertionsRequest *(const QString &)>(56, 6, QMC::AccessPublic, 0x80000000 | 57, {{
            { QMetaType::QString, 58 },
        }}),
        // Method 'addAssertions'
        QtMocHelpers::MethodData<QSnapdAddAssertionsRequest *(const QStringList &)>(59, 6, QMC::AccessPublic, 0x80000000 | 60, {{
            { QMetaType::QStringList, 61 },
        }}),
        // Method 'getConnections'
        QtMocHelpers::MethodData<QSnapdGetConnectionsRequest *()>(62, 6, QMC::AccessPublic, 0x80000000 | 63),
        // Method 'getConnections'
        QtMocHelpers::MethodData<QSnapdGetConnectionsRequest *(GetConnectionsFlags)>(62, 6, QMC::AccessPublic, 0x80000000 | 63, {{
            { 0x80000000 | 64, 38 },
        }}),
        // Method 'getConnections'
        QtMocHelpers::MethodData<QSnapdGetConnectionsRequest *(const QString &, const QString &)>(62, 6, QMC::AccessPublic, 0x80000000 | 63, {{
            { QMetaType::QString, 40 }, { QMetaType::QString, 65 },
        }}),
        // Method 'getConnections'
        QtMocHelpers::MethodData<QSnapdGetConnectionsRequest *(GetConnectionsFlags, const QString &, const QString &)>(62, 6, QMC::AccessPublic, 0x80000000 | 63, {{
            { 0x80000000 | 64, 38 }, { QMetaType::QString, 40 }, { QMetaType::QString, 65 },
        }}),
        // Method 'getInterfaces'
        QtMocHelpers::MethodData<QSnapdGetInterfacesRequest *()>(66, 6, QMC::AccessPublic, 0x80000000 | 67),
        // Method 'getInterfaces2'
        QtMocHelpers::MethodData<QSnapdGetInterfaces2Request *()>(68, 6, QMC::AccessPublic, 0x80000000 | 69),
        // Method 'getInterfaces2'
        QtMocHelpers::MethodData<QSnapdGetInterfaces2Request *(InterfaceFlags)>(68, 6, QMC::AccessPublic, 0x80000000 | 69, {{
            { 0x80000000 | 70, 38 },
        }}),
        // Method 'getInterfaces2'
        QtMocHelpers::MethodData<QSnapdGetInterfaces2Request *(const QStringList &)>(68, 6, QMC::AccessPublic, 0x80000000 | 69, {{
            { QMetaType::QStringList, 71 },
        }}),
        // Method 'getInterfaces2'
        QtMocHelpers::MethodData<QSnapdGetInterfaces2Request *(InterfaceFlags, const QStringList &)>(68, 6, QMC::AccessPublic, 0x80000000 | 69, {{
            { 0x80000000 | 70, 38 }, { QMetaType::QStringList, 71 },
        }}),
        // Method 'connectInterface'
        QtMocHelpers::MethodData<QSnapdConnectInterfaceRequest *(const QString &, const QString &, const QString &, const QString &)>(72, 6, QMC::AccessPublic, 0x80000000 | 73, {{
            { QMetaType::QString, 74 }, { QMetaType::QString, 75 }, { QMetaType::QString, 76 }, { QMetaType::QString, 77 },
        }}),
        // Method 'disconnectInterface'
        QtMocHelpers::MethodData<QSnapdDisconnectInterfaceRequest *(const QString &, const QString &, const QString &, const QString &)>(78, 6, QMC::AccessPublic, 0x80000000 | 79, {{
            { QMetaType::QString, 74 }, { QMetaType::QString, 75 }, { QMetaType::QString, 76 }, { QMetaType::QString, 77 },
        }}),
        // Method 'find'
        QtMocHelpers::MethodData<QSnapdFindRequest *(const QString &)>(80, 6, QMC::AccessPublic, 0x80000000 | 81, {{
            { QMetaType::QString, 82 },
        }}),
        // Method 'find'
        QtMocHelpers::MethodData<QSnapdFindRequest *(FindFlags)>(80, 6, QMC::AccessPublic, 0x80000000 | 81, {{
            { 0x80000000 | 83, 38 },
        }}),
        // Method 'find'
        QtMocHelpers::MethodData<QSnapdFindRequest *(FindFlags, const QString &)>(80, 6, QMC::AccessPublic, 0x80000000 | 81, {{
            { 0x80000000 | 83, 38 }, { QMetaType::QString, 82 },
        }}),
        // Method 'findCategory'
        QtMocHelpers::MethodData<QSnapdFindRequest *(const QString &, const QString &)>(84, 6, QMC::AccessPublic, 0x80000000 | 81, {{
            { QMetaType::QString, 85 }, { QMetaType::QString, 82 },
        }}),
        // Method 'findCategory'
        QtMocHelpers::MethodData<QSnapdFindRequest *(FindFlags, const QString &, const QString &)>(84, 6, QMC::AccessPublic, 0x80000000 | 81, {{
            { 0x80000000 | 83, 38 }, { QMetaType::QString, 85 }, { QMetaType::QString, 82 },
        }}),
        // Method 'findRefreshable'
        QtMocHelpers::MethodData<QSnapdFindRefreshableRequest *()>(86, 6, QMC::AccessPublic, 0x80000000 | 87),
        // Method 'install'
        QtMocHelpers::MethodData<QSnapdInstallRequest *(const QString &)>(88, 6, QMC::AccessPublic, 0x80000000 | 89, {{
            { QMetaType::QString, 43 },
        }}),
        // Method 'install'
        QtMocHelpers::MethodData<QSnapdInstallRequest *(const QString &, const QString &)>(88, 6, QMC::AccessPublic, 0x80000000 | 89, {{
            { QMetaType::QString, 43 }, { QMetaType::QString, 90 },
        }}),
        // Method 'install'
        QtMocHelpers::MethodData<QSnapdInstallRequest *(const QString &, const QString &, const QString &)>(88, 6, QMC::AccessPublic, 0x80000000 | 89, {{
            { QMetaType::QString, 43 }, { QMetaType::QString, 90 }, { QMetaType::QString, 91 },
        }}),
        // Method 'install'
        QtMocHelpers::MethodData<QSnapdInstallRequest *(InstallFlags, const QString &)>(88, 6, QMC::AccessPublic, 0x80000000 | 89, {{
            { 0x80000000 | 92, 38 }, { QMetaType::QString, 43 },
        }}),
        // Method 'install'
        QtMocHelpers::MethodData<QSnapdInstallRequest *(InstallFlags, const QString &, const QString &)>(88, 6, QMC::AccessPublic, 0x80000000 | 89, {{
            { 0x80000000 | 92, 38 }, { QMetaType::QString, 43 }, { QMetaType::QString, 90 },
        }}),
        // Method 'install'
        QtMocHelpers::MethodData<QSnapdInstallRequest *(InstallFlags, const QString &, const QString &, const QString &)>(88, 6, QMC::AccessPublic, 0x80000000 | 89, {{
            { 0x80000000 | 92, 38 }, { QMetaType::QString, 43 }, { QMetaType::QString, 90 }, { QMetaType::QString, 91 },
        }}),
        // Method 'install'
        QtMocHelpers::MethodData<QSnapdInstallRequest *(QIODevice *)>(88, 6, QMC::AccessPublic, 0x80000000 | 89, {{
            { 0x80000000 | 93, 94 },
        }}),
        // Method 'install'
        QtMocHelpers::MethodData<QSnapdInstallRequest *(InstallFlags, QIODevice *)>(88, 6, QMC::AccessPublic, 0x80000000 | 89, {{
            { 0x80000000 | 92, 38 }, { 0x80000000 | 93, 94 },
        }}),
        // Method 'trySnap'
        QtMocHelpers::MethodData<QSnapdTryRequest *(const QString &)>(95, 6, QMC::AccessPublic, 0x80000000 | 96, {{
            { QMetaType::QString, 97 },
        }}),
        // Method 'refresh'
        QtMocHelpers::MethodData<QSnapdRefreshRequest *(const QString &)>(98, 6, QMC::AccessPublic, 0x80000000 | 99, {{
            { QMetaType::QString, 43 },
        }}),
        // Method 'refresh'
        QtMocHelpers::MethodData<QSnapdRefreshRequest *(const QString &, const QString &)>(98, 6, QMC::AccessPublic, 0x80000000 | 99, {{
            { QMetaType::QString, 43 }, { QMetaType::QString, 90 },
        }}),
        // Method 'refreshAll'
        QtMocHelpers::MethodData<QSnapdRefreshAllRequest *()>(100, 6, QMC::AccessPublic, 0x80000000 | 101),
        // Method 'remove'
        QtMocHelpers::MethodData<QSnapdRemoveRequest *(const QString &)>(102, 6, QMC::AccessPublic, 0x80000000 | 103, {{
            { QMetaType::QString, 43 },
        }}),
        // Method 'remove'
        QtMocHelpers::MethodData<QSnapdRemoveRequest *(RemoveFlags, const QString &)>(102, 6, QMC::AccessPublic, 0x80000000 | 103, {{
            { 0x80000000 | 104, 38 }, { QMetaType::QString, 43 },
        }}),
        // Method 'enable'
        QtMocHelpers::MethodData<QSnapdEnableRequest *(const QString &)>(105, 6, QMC::AccessPublic, 0x80000000 | 106, {{
            { QMetaType::QString, 43 },
        }}),
        // Method 'disable'
        QtMocHelpers::MethodData<QSnapdDisableRequest *(const QString &)>(107, 6, QMC::AccessPublic, 0x80000000 | 108, {{
            { QMetaType::QString, 43 },
        }}),
        // Method 'switchChannel'
        QtMocHelpers::MethodData<QSnapdSwitchChannelRequest *(const QString &, const QString &)>(109, 6, QMC::AccessPublic, 0x80000000 | 110, {{
            { QMetaType::QString, 43 }, { QMetaType::QString, 90 },
        }}),
        // Method 'checkBuy'
        QtMocHelpers::MethodData<QSnapdCheckBuyRequest *()>(111, 6, QMC::AccessPublic, 0x80000000 | 112),
        // Method 'buy'
        QtMocHelpers::MethodData<QSnapdBuyRequest *(const QString &, double, const QString &)>(113, 6, QMC::AccessPublic, 0x80000000 | 114, {{
            { QMetaType::QString, 12 }, { QMetaType::Double, 115 }, { QMetaType::QString, 116 },
        }}),
        // Method 'createUser'
        QtMocHelpers::MethodData<QSnapdCreateUserRequest *(const QString &)>(117, 6, QMC::AccessPublic, 0x80000000 | 118, {{
            { QMetaType::QString, 7 },
        }}),
        // Method 'createUser'
        QtMocHelpers::MethodData<QSnapdCreateUserRequest *(const QString &, CreateUserFlags)>(117, 6, QMC::AccessPublic, 0x80000000 | 118, {{
            { QMetaType::QString, 7 }, { 0x80000000 | 119, 38 },
        }}),
        // Method 'createUsers'
        QtMocHelpers::MethodData<QSnapdCreateUsersRequest *()>(120, 6, QMC::AccessPublic, 0x80000000 | 121),
        // Method 'getUsers'
        QtMocHelpers::MethodData<QSnapdGetUsersRequest *()>(122, 6, QMC::AccessPublic, 0x80000000 | 123),
        // Method 'getCategories'
        QtMocHelpers::MethodData<QSnapdGetCategoriesRequest *()>(124, 6, QMC::AccessPublic, 0x80000000 | 125),
        // Method 'getAliases'
        QtMocHelpers::MethodData<QSnapdGetAliasesRequest *()>(126, 6, QMC::AccessPublic, 0x80000000 | 127),
        // Method 'alias'
        QtMocHelpers::MethodData<QSnapdAliasRequest *(const QString &, const QString &, const QString &)>(128, 6, QMC::AccessPublic, 0x80000000 | 129, {{
            { QMetaType::QString, 40 }, { QMetaType::QString, 130 }, { QMetaType::QString, 128 },
        }}),
        // Method 'unalias'
        QtMocHelpers::MethodData<QSnapdUnaliasRequest *(const QString &, const QString &)>(131, 6, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QString, 40 }, { QMetaType::QString, 128 },
        }}),
        // Method 'unalias'
        QtMocHelpers::MethodData<QSnapdUnaliasRequest *(const QString &)>(131, 6, QMC::AccessPublic, 0x80000000 | 132, {{
            { QMetaType::QString, 128 },
        }}),
        // Method 'prefer'
        QtMocHelpers::MethodData<QSnapdPreferRequest *(const QString &)>(133, 6, QMC::AccessPublic, 0x80000000 | 134, {{
            { QMetaType::QString, 40 },
        }}),
        // Method 'enableAliases'
        QtMocHelpers::MethodData<QSnapdEnableAliasesRequest *(const QString, const QStringList &)>(135, 3, QMC::AccessPublic, 0x80000000 | 136, {{
            { QMetaType::QString, 40 }, { QMetaType::QStringList, 137 },
        }}),
        // Method 'disableAliases'
        QtMocHelpers::MethodData<QSnapdDisableAliasesRequest *(const QString, const QStringList &)>(138, 3, QMC::AccessPublic, 0x80000000 | 139, {{
            { QMetaType::QString, 40 }, { QMetaType::QStringList, 137 },
        }}),
        // Method 'resetAliases'
        QtMocHelpers::MethodData<QSnapdResetAliasesRequest *(const QString, const QStringList &)>(140, 3, QMC::AccessPublic, 0x80000000 | 141, {{
            { QMetaType::QString, 40 }, { QMetaType::QStringList, 137 },
        }}),
        // Method 'runSnapCtl'
        QtMocHelpers::MethodData<QSnapdRunSnapCtlRequest *(const QString, const QStringList &)>(142, 6, QMC::AccessPublic, 0x80000000 | 143, {{
            { QMetaType::QString, 144 }, { QMetaType::QStringList, 145 },
        }}),
        // Method 'download'
        QtMocHelpers::MethodData<QSnapdDownloadRequest *(const QString &)>(146, 6, QMC::AccessPublic, 0x80000000 | 147, {{
            { QMetaType::QString, 43 },
        }}),
        // Method 'download'
        QtMocHelpers::MethodData<QSnapdDownloadRequest *(const QString &, const QString &, const QString &)>(146, 6, QMC::AccessPublic, 0x80000000 | 147, {{
            { QMetaType::QString, 43 }, { QMetaType::QString, 90 }, { QMetaType::QString, 91 },
        }}),
        // Method 'checkThemes'
        QtMocHelpers::MethodData<QSnapdCheckThemesRequest *(const QStringList &, const QStringList &, const QStringList &)>(148, 6, QMC::AccessPublic, 0x80000000 | 149, {{
            { QMetaType::QStringList, 150 }, { QMetaType::QStringList, 151 }, { QMetaType::QStringList, 152 },
        }}),
        // Method 'installThemes'
        QtMocHelpers::MethodData<QSnapdInstallThemesRequest *(const QStringList &, const QStringList &, const QStringList &)>(153, 6, QMC::AccessPublic, 0x80000000 | 154, {{
            { QMetaType::QStringList, 150 }, { QMetaType::QStringList, 151 }, { QMetaType::QStringList, 152 },
        }}),
        // Method 'getNotices'
        QtMocHelpers::MethodData<QSnapdNoticesRequest *()>(155, 6, QMC::AccessPublic, 0x80000000 | 156),
        // Method 'getModelAssertion'
        QtMocHelpers::MethodData<QSnapdGetModelAssertionRequest *()>(157, 6, QMC::AccessPublic, 0x80000000 | 158),
        // Method 'getSerialAssertion'
        QtMocHelpers::MethodData<QSnapdGetSerialAssertionRequest *()>(159, 6, QMC::AccessPublic, 0x80000000 | 160),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'socketPath'
        QtMocHelpers::PropertyData<QString>(14, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'userAgent'
        QtMocHelpers::PropertyData<QString>(16, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
        // property 'allowInteraction'
        QtMocHelpers::PropertyData<bool>(18, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'ChangeFilter'
        QtMocHelpers::EnumData<enum ChangeFilter>(26, 26, QMC::EnumFlags{}).add({
            {  161, ChangeFilter::FilterAll },
            {  162, ChangeFilter::FilterInProgress },
            {  163, ChangeFilter::FilterReady },
        }),
        // flag 'GetConnectionsFlags'
        QtMocHelpers::EnumData<GetConnectionsFlags>(64, 164, QMC::EnumIsFlag).add({
            {  165, GetConnectionsFlag::SelectAll },
        }),
        // flag 'FindFlags'
        QtMocHelpers::EnumData<FindFlags>(83, 166, QMC::EnumIsFlag).add({
            {  167, FindFlag::None },
            {  168, FindFlag::MatchName },
            {  169, FindFlag::SelectPrivate },
            {  170, FindFlag::ScopeWide },
            {  171, FindFlag::MatchCommonId },
        }),
    };
    return QtMocHelpers::metaObjectData<QSnapdClient, qt_meta_tag_ZN12QSnapdClientE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject QSnapdClient::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QSnapdClientE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12QSnapdClientE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12QSnapdClientE_t>.metaTypes,
    nullptr
} };

void QSnapdClient::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<QSnapdClient *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QSnapdConnectRequest* _r = _t->connect();
            if (_a[0]) *reinterpret_cast<QSnapdConnectRequest**>(_a[0]) = std::move(_r); }  break;
        case 1: { QSnapdLoginRequest* _r = _t->login((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdLoginRequest**>(_a[0]) = std::move(_r); }  break;
        case 2: { QSnapdLoginRequest* _r = _t->login((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QSnapdLoginRequest**>(_a[0]) = std::move(_r); }  break;
        case 3: { QSnapdLogoutRequest* _r = _t->logout((*reinterpret_cast<std::add_pointer_t<qint64>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdLogoutRequest**>(_a[0]) = std::move(_r); }  break;
        case 4: _t->setSocketPath((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 5: { QString _r = _t->socketPath();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 6: _t->setUserAgent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 7: { QString _r = _t->userAgent();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 8: _t->setAllowInteraction((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: { bool _r = _t->allowInteraction();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 10: { QSnapdMaintenance* _r = _t->maintenance();
            if (_a[0]) *reinterpret_cast<QSnapdMaintenance**>(_a[0]) = std::move(_r); }  break;
        case 11: _t->setAuthData((*reinterpret_cast<std::add_pointer_t<QSnapdAuthData*>>(_a[1]))); break;
        case 12: { QSnapdAuthData* _r = _t->authData();
            if (_a[0]) *reinterpret_cast<QSnapdAuthData**>(_a[0]) = std::move(_r); }  break;
        case 13: { QSnapdGetChangesRequest* _r = _t->getChanges();
            if (_a[0]) *reinterpret_cast<QSnapdGetChangesRequest**>(_a[0]) = std::move(_r); }  break;
        case 14: { QSnapdGetChangesRequest* _r = _t->getChanges((*reinterpret_cast<std::add_pointer_t<enum ChangeFilter>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetChangesRequest**>(_a[0]) = std::move(_r); }  break;
        case 15: { QSnapdGetChangesRequest* _r = _t->getChanges((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetChangesRequest**>(_a[0]) = std::move(_r); }  break;
        case 16: { QSnapdGetChangesRequest* _r = _t->getChanges((*reinterpret_cast<std::add_pointer_t<enum ChangeFilter>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdGetChangesRequest**>(_a[0]) = std::move(_r); }  break;
        case 17: { QSnapdGetChangeRequest* _r = _t->getChange((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetChangeRequest**>(_a[0]) = std::move(_r); }  break;
        case 18: { QSnapdAbortChangeRequest* _r = _t->abortChange((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdAbortChangeRequest**>(_a[0]) = std::move(_r); }  break;
        case 19: { QSnapdGetSystemInformationRequest* _r = _t->getSystemInformation();
            if (_a[0]) *reinterpret_cast<QSnapdGetSystemInformationRequest**>(_a[0]) = std::move(_r); }  break;
        case 20: { QSnapdGetSnapsRequest* _r = _t->getSnaps((*reinterpret_cast<std::add_pointer_t<GetSnapsFlags>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdGetSnapsRequest**>(_a[0]) = std::move(_r); }  break;
        case 21: { QSnapdGetSnapsRequest* _r = _t->getSnaps((*reinterpret_cast<std::add_pointer_t<GetSnapsFlags>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdGetSnapsRequest**>(_a[0]) = std::move(_r); }  break;
        case 22: { QSnapdGetSnapsRequest* _r = _t->getSnaps((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetSnapsRequest**>(_a[0]) = std::move(_r); }  break;
        case 23: { QSnapdGetSnapsRequest* _r = _t->getSnaps((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetSnapsRequest**>(_a[0]) = std::move(_r); }  break;
        case 24: { QSnapdGetSnapsRequest* _r = _t->getSnaps();
            if (_a[0]) *reinterpret_cast<QSnapdGetSnapsRequest**>(_a[0]) = std::move(_r); }  break;
        case 25: { QSnapdGetSnapRequest* _r = _t->getSnap((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetSnapRequest**>(_a[0]) = std::move(_r); }  break;
        case 26: { QSnapdGetSnapConfRequest* _r = _t->getSnapConf((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetSnapConfRequest**>(_a[0]) = std::move(_r); }  break;
        case 27: { QSnapdGetSnapConfRequest* _r = _t->getSnapConf((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdGetSnapConfRequest**>(_a[0]) = std::move(_r); }  break;
        case 28: { QSnapdSetSnapConfRequest* _r = _t->setSnapConf((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QHash<QString,QVariant>>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdSetSnapConfRequest**>(_a[0]) = std::move(_r); }  break;
        case 29: { QSnapdGetAppsRequest* _r = _t->getApps();
            if (_a[0]) *reinterpret_cast<QSnapdGetAppsRequest**>(_a[0]) = std::move(_r); }  break;
        case 30: { QSnapdGetAppsRequest* _r = _t->getApps((*reinterpret_cast<std::add_pointer_t<GetAppsFlags>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetAppsRequest**>(_a[0]) = std::move(_r); }  break;
        case 31: { QSnapdGetAppsRequest* _r = _t->getApps((*reinterpret_cast<std::add_pointer_t<GetAppsFlags>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdGetAppsRequest**>(_a[0]) = std::move(_r); }  break;
        case 32: { QSnapdGetAppsRequest* _r = _t->getApps((*reinterpret_cast<std::add_pointer_t<GetAppsFlags>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdGetAppsRequest**>(_a[0]) = std::move(_r); }  break;
        case 33: { QSnapdGetAppsRequest* _r = _t->getApps((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetAppsRequest**>(_a[0]) = std::move(_r); }  break;
        case 34: { QSnapdGetAppsRequest* _r = _t->getApps((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetAppsRequest**>(_a[0]) = std::move(_r); }  break;
        case 35: { QSnapdGetIconRequest* _r = _t->getIcon((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetIconRequest**>(_a[0]) = std::move(_r); }  break;
        case 36: { QSnapdGetAssertionsRequest* _r = _t->getAssertions((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetAssertionsRequest**>(_a[0]) = std::move(_r); }  break;
        case 37: { QSnapdAddAssertionsRequest* _r = _t->addAssertions((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdAddAssertionsRequest**>(_a[0]) = std::move(_r); }  break;
        case 38: { QSnapdGetConnectionsRequest* _r = _t->getConnections();
            if (_a[0]) *reinterpret_cast<QSnapdGetConnectionsRequest**>(_a[0]) = std::move(_r); }  break;
        case 39: { QSnapdGetConnectionsRequest* _r = _t->getConnections((*reinterpret_cast<std::add_pointer_t<GetConnectionsFlags>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetConnectionsRequest**>(_a[0]) = std::move(_r); }  break;
        case 40: { QSnapdGetConnectionsRequest* _r = _t->getConnections((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdGetConnectionsRequest**>(_a[0]) = std::move(_r); }  break;
        case 41: { QSnapdGetConnectionsRequest* _r = _t->getConnections((*reinterpret_cast<std::add_pointer_t<GetConnectionsFlags>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QSnapdGetConnectionsRequest**>(_a[0]) = std::move(_r); }  break;
        case 42: { QSnapdGetInterfacesRequest* _r = _t->getInterfaces();
            if (_a[0]) *reinterpret_cast<QSnapdGetInterfacesRequest**>(_a[0]) = std::move(_r); }  break;
        case 43: { QSnapdGetInterfaces2Request* _r = _t->getInterfaces2();
            if (_a[0]) *reinterpret_cast<QSnapdGetInterfaces2Request**>(_a[0]) = std::move(_r); }  break;
        case 44: { QSnapdGetInterfaces2Request* _r = _t->getInterfaces2((*reinterpret_cast<std::add_pointer_t<InterfaceFlags>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetInterfaces2Request**>(_a[0]) = std::move(_r); }  break;
        case 45: { QSnapdGetInterfaces2Request* _r = _t->getInterfaces2((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdGetInterfaces2Request**>(_a[0]) = std::move(_r); }  break;
        case 46: { QSnapdGetInterfaces2Request* _r = _t->getInterfaces2((*reinterpret_cast<std::add_pointer_t<InterfaceFlags>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdGetInterfaces2Request**>(_a[0]) = std::move(_r); }  break;
        case 47: { QSnapdConnectInterfaceRequest* _r = _t->connectInterface((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4])));
            if (_a[0]) *reinterpret_cast<QSnapdConnectInterfaceRequest**>(_a[0]) = std::move(_r); }  break;
        case 48: { QSnapdDisconnectInterfaceRequest* _r = _t->disconnectInterface((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4])));
            if (_a[0]) *reinterpret_cast<QSnapdDisconnectInterfaceRequest**>(_a[0]) = std::move(_r); }  break;
        case 49: { QSnapdFindRequest* _r = _t->find((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdFindRequest**>(_a[0]) = std::move(_r); }  break;
        case 50: { QSnapdFindRequest* _r = _t->find((*reinterpret_cast<std::add_pointer_t<FindFlags>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdFindRequest**>(_a[0]) = std::move(_r); }  break;
        case 51: { QSnapdFindRequest* _r = _t->find((*reinterpret_cast<std::add_pointer_t<FindFlags>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdFindRequest**>(_a[0]) = std::move(_r); }  break;
        case 52: { QSnapdFindRequest* _r = _t->findCategory((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdFindRequest**>(_a[0]) = std::move(_r); }  break;
        case 53: { QSnapdFindRequest* _r = _t->findCategory((*reinterpret_cast<std::add_pointer_t<FindFlags>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QSnapdFindRequest**>(_a[0]) = std::move(_r); }  break;
        case 54: { QSnapdFindRefreshableRequest* _r = _t->findRefreshable();
            if (_a[0]) *reinterpret_cast<QSnapdFindRefreshableRequest**>(_a[0]) = std::move(_r); }  break;
        case 55: { QSnapdInstallRequest* _r = _t->install((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdInstallRequest**>(_a[0]) = std::move(_r); }  break;
        case 56: { QSnapdInstallRequest* _r = _t->install((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdInstallRequest**>(_a[0]) = std::move(_r); }  break;
        case 57: { QSnapdInstallRequest* _r = _t->install((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QSnapdInstallRequest**>(_a[0]) = std::move(_r); }  break;
        case 58: { QSnapdInstallRequest* _r = _t->install((*reinterpret_cast<std::add_pointer_t<InstallFlags>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdInstallRequest**>(_a[0]) = std::move(_r); }  break;
        case 59: { QSnapdInstallRequest* _r = _t->install((*reinterpret_cast<std::add_pointer_t<InstallFlags>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QSnapdInstallRequest**>(_a[0]) = std::move(_r); }  break;
        case 60: { QSnapdInstallRequest* _r = _t->install((*reinterpret_cast<std::add_pointer_t<InstallFlags>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[4])));
            if (_a[0]) *reinterpret_cast<QSnapdInstallRequest**>(_a[0]) = std::move(_r); }  break;
        case 61: { QSnapdInstallRequest* _r = _t->install((*reinterpret_cast<std::add_pointer_t<QIODevice*>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdInstallRequest**>(_a[0]) = std::move(_r); }  break;
        case 62: { QSnapdInstallRequest* _r = _t->install((*reinterpret_cast<std::add_pointer_t<InstallFlags>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QIODevice*>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdInstallRequest**>(_a[0]) = std::move(_r); }  break;
        case 63: { QSnapdTryRequest* _r = _t->trySnap((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdTryRequest**>(_a[0]) = std::move(_r); }  break;
        case 64: { QSnapdRefreshRequest* _r = _t->refresh((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdRefreshRequest**>(_a[0]) = std::move(_r); }  break;
        case 65: { QSnapdRefreshRequest* _r = _t->refresh((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdRefreshRequest**>(_a[0]) = std::move(_r); }  break;
        case 66: { QSnapdRefreshAllRequest* _r = _t->refreshAll();
            if (_a[0]) *reinterpret_cast<QSnapdRefreshAllRequest**>(_a[0]) = std::move(_r); }  break;
        case 67: { QSnapdRemoveRequest* _r = _t->remove((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdRemoveRequest**>(_a[0]) = std::move(_r); }  break;
        case 68: { QSnapdRemoveRequest* _r = _t->remove((*reinterpret_cast<std::add_pointer_t<RemoveFlags>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdRemoveRequest**>(_a[0]) = std::move(_r); }  break;
        case 69: { QSnapdEnableRequest* _r = _t->enable((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdEnableRequest**>(_a[0]) = std::move(_r); }  break;
        case 70: { QSnapdDisableRequest* _r = _t->disable((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdDisableRequest**>(_a[0]) = std::move(_r); }  break;
        case 71: { QSnapdSwitchChannelRequest* _r = _t->switchChannel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdSwitchChannelRequest**>(_a[0]) = std::move(_r); }  break;
        case 72: { QSnapdCheckBuyRequest* _r = _t->checkBuy();
            if (_a[0]) *reinterpret_cast<QSnapdCheckBuyRequest**>(_a[0]) = std::move(_r); }  break;
        case 73: { QSnapdBuyRequest* _r = _t->buy((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<double>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QSnapdBuyRequest**>(_a[0]) = std::move(_r); }  break;
        case 74: { QSnapdCreateUserRequest* _r = _t->createUser((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdCreateUserRequest**>(_a[0]) = std::move(_r); }  break;
        case 75: { QSnapdCreateUserRequest* _r = _t->createUser((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<CreateUserFlags>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdCreateUserRequest**>(_a[0]) = std::move(_r); }  break;
        case 76: { QSnapdCreateUsersRequest* _r = _t->createUsers();
            if (_a[0]) *reinterpret_cast<QSnapdCreateUsersRequest**>(_a[0]) = std::move(_r); }  break;
        case 77: { QSnapdGetUsersRequest* _r = _t->getUsers();
            if (_a[0]) *reinterpret_cast<QSnapdGetUsersRequest**>(_a[0]) = std::move(_r); }  break;
        case 78: { QSnapdGetCategoriesRequest* _r = _t->getCategories();
            if (_a[0]) *reinterpret_cast<QSnapdGetCategoriesRequest**>(_a[0]) = std::move(_r); }  break;
        case 79: { QSnapdGetAliasesRequest* _r = _t->getAliases();
            if (_a[0]) *reinterpret_cast<QSnapdGetAliasesRequest**>(_a[0]) = std::move(_r); }  break;
        case 80: { QSnapdAliasRequest* _r = _t->alias((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QSnapdAliasRequest**>(_a[0]) = std::move(_r); }  break;
        case 81: { QSnapdUnaliasRequest* _r = _t->unalias((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdUnaliasRequest**>(_a[0]) = std::move(_r); }  break;
        case 82: { QSnapdUnaliasRequest* _r = _t->unalias((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdUnaliasRequest**>(_a[0]) = std::move(_r); }  break;
        case 83: { QSnapdPreferRequest* _r = _t->prefer((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdPreferRequest**>(_a[0]) = std::move(_r); }  break;
        case 84: { QSnapdEnableAliasesRequest* _r = _t->enableAliases((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdEnableAliasesRequest**>(_a[0]) = std::move(_r); }  break;
        case 85: { QSnapdDisableAliasesRequest* _r = _t->disableAliases((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdDisableAliasesRequest**>(_a[0]) = std::move(_r); }  break;
        case 86: { QSnapdResetAliasesRequest* _r = _t->resetAliases((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdResetAliasesRequest**>(_a[0]) = std::move(_r); }  break;
        case 87: { QSnapdRunSnapCtlRequest* _r = _t->runSnapCtl((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QSnapdRunSnapCtlRequest**>(_a[0]) = std::move(_r); }  break;
        case 88: { QSnapdDownloadRequest* _r = _t->download((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QSnapdDownloadRequest**>(_a[0]) = std::move(_r); }  break;
        case 89: { QSnapdDownloadRequest* _r = _t->download((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QSnapdDownloadRequest**>(_a[0]) = std::move(_r); }  break;
        case 90: { QSnapdCheckThemesRequest* _r = _t->checkThemes((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QSnapdCheckThemesRequest**>(_a[0]) = std::move(_r); }  break;
        case 91: { QSnapdInstallThemesRequest* _r = _t->installThemes((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QSnapdInstallThemesRequest**>(_a[0]) = std::move(_r); }  break;
        case 92: { QSnapdNoticesRequest* _r = _t->getNotices();
            if (_a[0]) *reinterpret_cast<QSnapdNoticesRequest**>(_a[0]) = std::move(_r); }  break;
        case 93: { QSnapdGetModelAssertionRequest* _r = _t->getModelAssertion();
            if (_a[0]) *reinterpret_cast<QSnapdGetModelAssertionRequest**>(_a[0]) = std::move(_r); }  break;
        case 94: { QSnapdGetSerialAssertionRequest* _r = _t->getSerialAssertion();
            if (_a[0]) *reinterpret_cast<QSnapdGetSerialAssertionRequest**>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->socketPath(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->userAgent(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->allowInteraction(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setSocketPath(*reinterpret_cast<QString*>(_v)); break;
        case 1: _t->setUserAgent(*reinterpret_cast<QString*>(_v)); break;
        case 2: _t->setAllowInteraction(*reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}

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

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

int QSnapdClient::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 < 95)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 95;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 95)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 95;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    return _id;
}
QT_WARNING_POP
