/****************************************************************************
** Meta object code from reading C++ file 'dbustype.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 "../../../../../plasma-workspace-6.7.1/components/dbus/dbustype.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 'dbustype.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_ZN6Plasma4DBus4BOOLE_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::BOOL::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus4BOOLE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::BOOL",
        "QML.Element",
        "bool",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "BOOL",
        "value"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<bool>(10, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(bool)>(8, QMC::AccessPublic, {{
            { QMetaType::Bool, 10 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<BOOL, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::BOOL::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus4BOOLE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus4BOOLE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus4BOOLE_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::BOOL::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<BOOL *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { BOOL *_r = new BOOL((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) BOOL((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN6Plasma4DBus5INT16E_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::INT16::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus5INT16E_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::INT16",
        "QML.Element",
        "int16",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "INT16",
        "value"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<short>(10, QMetaType::Short, QMC::DefaultPropertyFlags | QMC::Writable),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(int)>(8, QMC::AccessPublic, {{
            { QMetaType::Int, 10 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<INT16, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::INT16::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus5INT16E_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus5INT16E_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus5INT16E_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::INT16::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<INT16 *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { INT16 *_r = new INT16((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) INT16((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<short*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<short*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN6Plasma4DBus5INT32E_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::INT32::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus5INT32E_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::INT32",
        "QML.Element",
        "int32",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "INT32",
        "value"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<int>(10, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(int)>(8, QMC::AccessPublic, {{
            { QMetaType::Int, 10 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<INT32, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::INT32::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus5INT32E_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus5INT32E_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus5INT32E_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::INT32::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<INT32 *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { INT32 *_r = new INT32((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) INT32((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<int*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN6Plasma4DBus5INT64E_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::INT64::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus5INT64E_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::INT64",
        "QML.Element",
        "int64",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "INT64",
        "value"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<qlonglong>(10, QMetaType::LongLong, QMC::DefaultPropertyFlags | QMC::Writable),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(double)>(8, QMC::AccessPublic, {{
            { QMetaType::Double, 10 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<INT64, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::INT64::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus5INT64E_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus5INT64E_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus5INT64E_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::INT64::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<INT64 *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { INT64 *_r = new INT64((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) INT64((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<qlonglong*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<qlonglong*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN6Plasma4DBus6UINT16E_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::UINT16::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus6UINT16E_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::UINT16",
        "QML.Element",
        "uint16",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "UINT16",
        "value"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<ushort>(10, QMetaType::UShort, QMC::DefaultPropertyFlags | QMC::Writable),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(int)>(8, QMC::AccessPublic, {{
            { QMetaType::Int, 10 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<UINT16, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::UINT16::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus6UINT16E_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus6UINT16E_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus6UINT16E_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::UINT16::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<UINT16 *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { UINT16 *_r = new UINT16((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) UINT16((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<ushort*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<ushort*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN6Plasma4DBus6UINT32E_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::UINT32::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus6UINT32E_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::UINT32",
        "QML.Element",
        "uint32",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "UINT32",
        "value"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<uint>(10, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Writable),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(double)>(8, QMC::AccessPublic, {{
            { QMetaType::Double, 10 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<UINT32, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::UINT32::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus6UINT32E_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus6UINT32E_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus6UINT32E_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::UINT32::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<UINT32 *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { UINT32 *_r = new UINT32((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) UINT32((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<uint*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<uint*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN6Plasma4DBus6UINT64E_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::UINT64::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus6UINT64E_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::UINT64",
        "QML.Element",
        "uint64",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "UINT64",
        "value"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<qulonglong>(10, QMetaType::ULongLong, QMC::DefaultPropertyFlags | QMC::Writable),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(double)>(8, QMC::AccessPublic, {{
            { QMetaType::Double, 10 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<UINT64, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::UINT64::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus6UINT64E_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus6UINT64E_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus6UINT64E_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::UINT64::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<UINT64 *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { UINT64 *_r = new UINT64((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) UINT64((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<qulonglong*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<qulonglong*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN6Plasma4DBus6DOUBLEE_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::DOUBLE::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus6DOUBLEE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::DOUBLE",
        "QML.Element",
        "double",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "DOUBLE",
        "value"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<double>(10, QMetaType::Double, QMC::DefaultPropertyFlags | QMC::Writable),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(double)>(8, QMC::AccessPublic, {{
            { QMetaType::Double, 10 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<DOUBLE, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::DOUBLE::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus6DOUBLEE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus6DOUBLEE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus6DOUBLEE_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::DOUBLE::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<DOUBLE *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { DOUBLE *_r = new DOUBLE((*reinterpret_cast<std::add_pointer_t<double>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) DOUBLE((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<double*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<double*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN6Plasma4DBus4BYTEE_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::BYTE::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus4BYTEE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::BYTE",
        "QML.Element",
        "byte",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "BYTE",
        "value"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<uchar>(10, QMetaType::UChar, QMC::DefaultPropertyFlags | QMC::Writable),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(int)>(8, QMC::AccessPublic, {{
            { QMetaType::Int, 10 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<BYTE, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::BYTE::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus4BYTEE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus4BYTEE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus4BYTEE_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::BYTE::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<BYTE *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { BYTE *_r = new BYTE((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) BYTE((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<uchar*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<uchar*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN6Plasma4DBus6STRINGE_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::STRING::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus6STRINGE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::STRING",
        "QML.Element",
        "string",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "STRING",
        "value"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<QString>(10, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(QString)>(8, QMC::AccessPublic, {{
            { QMetaType::QString, 10 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<STRING, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::STRING::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus6STRINGE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus6STRINGE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus6STRINGE_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::STRING::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<STRING *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { STRING *_r = new STRING((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) STRING((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN6Plasma4DBus9SIGNATUREE_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::SIGNATURE::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus9SIGNATUREE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::SIGNATURE",
        "QML.Element",
        "signature",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "SIGNATURE",
        "value",
        "QDBusSignature"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<QDBusSignature>(10, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(QString)>(8, QMC::AccessPublic, {{
            { QMetaType::QString, 10 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<SIGNATURE, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::SIGNATURE::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus9SIGNATUREE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus9SIGNATUREE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus9SIGNATUREE_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::SIGNATURE::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<SIGNATURE *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { SIGNATURE *_r = new SIGNATURE((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) SIGNATURE((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusSignature >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QDBusSignature*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<QDBusSignature*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN6Plasma4DBus10OBJECTPATHE_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::OBJECTPATH::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus10OBJECTPATHE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::OBJECTPATH",
        "QML.Element",
        "objectPath",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "OBJECTPATH",
        "value",
        "QDBusObjectPath"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<QDBusObjectPath>(10, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(QString)>(8, QMC::AccessPublic, {{
            { QMetaType::QString, 10 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<OBJECTPATH, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::OBJECTPATH::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus10OBJECTPATHE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus10OBJECTPATHE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus10OBJECTPATHE_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::OBJECTPATH::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<OBJECTPATH *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { OBJECTPATH *_r = new OBJECTPATH((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) OBJECTPATH((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusObjectPath >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QDBusObjectPath*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<QDBusObjectPath*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN6Plasma4DBus4DICTE_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::DICT::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus4DICTE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::DICT",
        "QML.Element",
        "dict",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "DICT",
        "QVariantMap",
        "value"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<QVariantMap>(11, 0x80000000 | 10, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(QVariantMap)>(8, QMC::AccessPublic, {{
            { 0x80000000 | 10, 11 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<DICT, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::DICT::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus4DICTE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus4DICTE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus4DICTE_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::DICT::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<DICT *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { DICT *_r = new DICT((*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) DICT((*reinterpret_cast<std::add_pointer_t<QVariantMap>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QVariantMap*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<QVariantMap*>(_v)); break;
        default: break;
        }
    }
}
namespace {
struct qt_meta_tag_ZN6Plasma4DBus7VARIANTE_t {};
} // unnamed namespace

template <> constexpr inline auto Plasma::DBus::VARIANT::qt_create_metaobjectdata<qt_meta_tag_ZN6Plasma4DBus7VARIANTE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Plasma::DBus::VARIANT",
        "QML.Element",
        "variant",
        "QML.Creatable",
        "true",
        "QML.CreationMethod",
        "construct",
        "toString",
        "",
        "VARIANT",
        "QJSValue",
        "value",
        "QDBusVariant"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'toString'
        QtMocHelpers::MethodData<QString() const>(7, 8, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'value'
        QtMocHelpers::PropertyData<QDBusVariant>(11, 0x80000000 | 12, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag),
    };
    QtMocHelpers::UintData qt_enums {
    };
    using Constructor = QtMocHelpers::NoType;
    QtMocHelpers::UintData qt_constructors {
        QtMocHelpers::ConstructorData<Constructor(const QJSValue &)>(8, QMC::AccessPublic, {{
            { 0x80000000 | 10, 11 },
        }}),
    };
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<VARIANT, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject Plasma::DBus::VARIANT::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus7VARIANTE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN6Plasma4DBus7VARIANTE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN6Plasma4DBus7VARIANTE_t>.metaTypes,
    nullptr
} };

void Plasma::DBus::VARIANT::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = reinterpret_cast<VARIANT *>(_o);
    if (_c == QMetaObject::CreateInstance) {
        switch (_id) {
        case 0: { VARIANT *_r = new VARIANT((*reinterpret_cast<std::add_pointer_t<QJSValue>>(_a[1])));
            if (_a[0]) *reinterpret_cast<void**>(_a[0]) = _r; } break;
        default: break;
        }
    }
    if (_c == QMetaObject::ConstructInPlace) {
        switch (_id) {
        case 0: { new (_a[0]) VARIANT((*reinterpret_cast<std::add_pointer_t<QJSValue>>(_a[1]))); } break;
        default: break;
        }
    }
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: { QString _r = _t->toString();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QDBusVariant >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QDBusVariant*>(_v) = _t->value; break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: QtMocHelpers::setProperty(_t->value, *reinterpret_cast<QDBusVariant*>(_v)); break;
        default: break;
        }
    }
}
QT_WARNING_POP
