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

#include "../../../../kdeconnect-kde-26.07.80/declarativeplugin/kdeconnectdeclarativeplugin.h"
#include <QtCore/qmetatype.h>
#include <QtCore/qplugin.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'kdeconnectdeclarativeplugin.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.12.0. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto KdeConnectPluginConfigForeign::qt_create_metaobjectdata<qt_meta_tag_ZN29KdeConnectPluginConfigForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "KdeConnectPluginConfigForeign",
        "QML.Element",
        "KdeConnectPluginConfig",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    2 },
    });
    return QtMocHelpers::metaObjectData<KdeConnectPluginConfigForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject KdeConnectPluginConfigForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29KdeConnectPluginConfigForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29KdeConnectPluginConfigForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN29KdeConnectPluginConfigForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN24DBusAsyncResponseForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto DBusAsyncResponseForeign::qt_create_metaobjectdata<qt_meta_tag_ZN24DBusAsyncResponseForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DBusAsyncResponseForeign",
        "QML.Element",
        "DBusAsyncResponse",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    2 },
    });
    return QtMocHelpers::metaObjectData<DBusAsyncResponseForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject DBusAsyncResponseForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24DBusAsyncResponseForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24DBusAsyncResponseForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24DBusAsyncResponseForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN20CommandsModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto CommandsModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN20CommandsModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CommandsModelForeign",
        "QML.Element",
        "CommandsModel",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    2 },
    });
    return QtMocHelpers::metaObjectData<CommandsModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject CommandsModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20CommandsModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20CommandsModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20CommandsModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN18PluginModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto PluginModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN18PluginModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PluginModelForeign",
        "QML.Element",
        "PluginModel",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    2 },
    });
    return QtMocHelpers::metaObjectData<PluginModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject PluginModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18PluginModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18PluginModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18PluginModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN19DevicesModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto DevicesModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN19DevicesModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DevicesModelForeign",
        "QML.Element",
        "DevicesModel",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    2 },
    });
    return QtMocHelpers::metaObjectData<DevicesModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject DevicesModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19DevicesModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19DevicesModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19DevicesModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN28DevicesSortProxyModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto DevicesSortProxyModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN28DevicesSortProxyModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DevicesSortProxyModelForeign",
        "QML.Element",
        "DevicesSortProxyModel",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    2 },
    });
    return QtMocHelpers::metaObjectData<DevicesSortProxyModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject DevicesSortProxyModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28DevicesSortProxyModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28DevicesSortProxyModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN28DevicesSortProxyModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN36DevicesPluginFilterProxyModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto DevicesPluginFilterProxyModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN36DevicesPluginFilterProxyModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DevicesPluginFilterProxyModelForeign",
        "QML.Element",
        "DevicesPluginFilterProxyModel",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    2 },
    });
    return QtMocHelpers::metaObjectData<DevicesPluginFilterProxyModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject DevicesPluginFilterProxyModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN36DevicesPluginFilterProxyModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN36DevicesPluginFilterProxyModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN36DevicesPluginFilterProxyModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN25NotificationsModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto NotificationsModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN25NotificationsModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "NotificationsModelForeign",
        "QML.Element",
        "NotificationsModel",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    2 },
    });
    return QtMocHelpers::metaObjectData<NotificationsModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject NotificationsModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25NotificationsModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25NotificationsModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN25NotificationsModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN26RemoteCommandsModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto RemoteCommandsModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN26RemoteCommandsModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RemoteCommandsModelForeign",
        "QML.Element",
        "RemoteCommandsModel",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    2 },
    });
    return QtMocHelpers::metaObjectData<RemoteCommandsModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RemoteCommandsModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26RemoteCommandsModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26RemoteCommandsModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26RemoteCommandsModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN23RemoteSinksModelForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto RemoteSinksModelForeign::qt_create_metaobjectdata<qt_meta_tag_ZN23RemoteSinksModelForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RemoteSinksModelForeign",
        "QML.Element",
        "RemoteSinksModel",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    2 },
    });
    return QtMocHelpers::metaObjectData<RemoteSinksModelForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RemoteSinksModelForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23RemoteSinksModelForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23RemoteSinksModelForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23RemoteSinksModelForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN27BatteryDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto BatteryDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN27BatteryDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "BatteryDbusInterfaceForeign",
        "QML.Element",
        "BatteryDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    2 },
    });
    return QtMocHelpers::metaObjectData<BatteryDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject BatteryDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27BatteryDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27BatteryDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27BatteryDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN26DeviceDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto DeviceDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN26DeviceDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DeviceDbusInterfaceForeign",
        "QML.Element",
        "DeviceDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    2 },
    });
    return QtMocHelpers::metaObjectData<DeviceDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject DeviceDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26DeviceDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26DeviceDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26DeviceDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN38ConnectivityReportDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto ConnectivityReportDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN38ConnectivityReportDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ConnectivityReportDbusInterfaceForeign",
        "QML.Element",
        "ConnectivityReportDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    2 },
    });
    return QtMocHelpers::metaObjectData<ConnectivityReportDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject ConnectivityReportDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN38ConnectivityReportDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN38ConnectivityReportDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN38ConnectivityReportDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN25ShareDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto ShareDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN25ShareDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ShareDbusInterfaceForeign",
        "QML.Element",
        "ShareDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    2 },
    });
    return QtMocHelpers::metaObjectData<ShareDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject ShareDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25ShareDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25ShareDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN25ShareDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN34VirtualmonitorDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto VirtualmonitorDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN34VirtualmonitorDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "VirtualmonitorDbusInterfaceForeign",
        "QML.Element",
        "VirtualmonitorDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    2 },
    });
    return QtMocHelpers::metaObjectData<VirtualmonitorDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject VirtualmonitorDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN34VirtualmonitorDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN34VirtualmonitorDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN34VirtualmonitorDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN24SftpDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto SftpDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN24SftpDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "SftpDbusInterfaceForeign",
        "QML.Element",
        "SftpDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    2 },
    });
    return QtMocHelpers::metaObjectData<SftpDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject SftpDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24SftpDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24SftpDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24SftpDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN29ClipboardDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto ClipboardDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN29ClipboardDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ClipboardDbusInterfaceForeign",
        "QML.Element",
        "ClipboardDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    2 },
    });
    return QtMocHelpers::metaObjectData<ClipboardDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject ClipboardDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29ClipboardDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29ClipboardDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN29ClipboardDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN34RemoteKeyboardDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto RemoteKeyboardDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN34RemoteKeyboardDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RemoteKeyboardDbusInterfaceForeign",
        "QML.Element",
        "RemoteKeyboardDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    2 },
    });
    return QtMocHelpers::metaObjectData<RemoteKeyboardDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RemoteKeyboardDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN34RemoteKeyboardDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN34RemoteKeyboardDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN34RemoteKeyboardDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN25MprisDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto MprisDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN25MprisDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "MprisDbusInterfaceForeign",
        "QML.Element",
        "MprisDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    2 },
    });
    return QtMocHelpers::metaObjectData<MprisDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject MprisDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25MprisDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25MprisDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN25MprisDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN30LockDeviceDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto LockDeviceDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN30LockDeviceDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LockDeviceDbusInterfaceForeign",
        "QML.Element",
        "LockDeviceDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    2 },
    });
    return QtMocHelpers::metaObjectData<LockDeviceDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject LockDeviceDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN30LockDeviceDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN30LockDeviceDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN30LockDeviceDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN37FindMyPhoneDeviceDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto FindMyPhoneDeviceDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN37FindMyPhoneDeviceDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "FindMyPhoneDeviceDbusInterfaceForeign",
        "QML.Element",
        "FindMyPhoneDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign",
        "FindMyPhoneDeviceDbusInterface"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    8 },
    });
    return QtMocHelpers::metaObjectData<FindMyPhoneDeviceDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject FindMyPhoneDeviceDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN37FindMyPhoneDeviceDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN37FindMyPhoneDeviceDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN37FindMyPhoneDeviceDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN23SmsDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto SmsDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN23SmsDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "SmsDbusInterfaceForeign",
        "QML.Element",
        "SmsDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    2 },
    });
    return QtMocHelpers::metaObjectData<SmsDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject SmsDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23SmsDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23SmsDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23SmsDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN34RemoteCommandsDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto RemoteCommandsDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN34RemoteCommandsDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RemoteCommandsDbusInterfaceForeign",
        "QML.Element",
        "RemoteCommandsDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    2 },
    });
    return QtMocHelpers::metaObjectData<RemoteCommandsDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RemoteCommandsDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN34RemoteCommandsDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN34RemoteCommandsDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN34RemoteCommandsDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN38RemoteSystemVolumeDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto RemoteSystemVolumeDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN38RemoteSystemVolumeDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RemoteSystemVolumeDbusInterfaceForeign",
        "QML.Element",
        "RemoteSystemVolumeDbusInterface",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
            {    7,    2 },
    });
    return QtMocHelpers::metaObjectData<RemoteSystemVolumeDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RemoteSystemVolumeDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN38RemoteSystemVolumeDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN38RemoteSystemVolumeDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN38RemoteSystemVolumeDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN26DaemonDbusInterfaceForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto DaemonDbusInterfaceForeign::qt_create_metaobjectdata<qt_meta_tag_ZN26DaemonDbusInterfaceForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DaemonDbusInterfaceForeign",
        "QML.Element",
        "DaemonDbusInterface",
        "QML.Singleton",
        "true",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    2 },
    });
    return QtMocHelpers::metaObjectData<DaemonDbusInterfaceForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject DaemonDbusInterfaceForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26DaemonDbusInterfaceForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26DaemonDbusInterfaceForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26DaemonDbusInterfaceForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN17OpenConfigForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto OpenConfigForeign::qt_create_metaobjectdata<qt_meta_tag_ZN17OpenConfigForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "OpenConfigForeign",
        "QML.Element",
        "OpenConfig",
        "QML.Singleton",
        "true",
        "QML.Foreign"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    2 },
    });
    return QtMocHelpers::metaObjectData<OpenConfigForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject OpenConfigForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17OpenConfigForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN17OpenConfigForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN17OpenConfigForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN26DeviceDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto DeviceDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN26DeviceDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DeviceDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "DeviceDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<DeviceDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<DeviceDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject DeviceDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26DeviceDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN26DeviceDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN26DeviceDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int DeviceDbusInterfaceFactory::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 < 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_ZN33DeviceBatteryDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto DeviceBatteryDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN33DeviceBatteryDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DeviceBatteryDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "BatteryDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<BatteryDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<DeviceBatteryDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject DeviceBatteryDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33DeviceBatteryDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33DeviceBatteryDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN33DeviceBatteryDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int DeviceBatteryDbusInterfaceFactory::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 < 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_ZN44DeviceConnectivityReportDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto DeviceConnectivityReportDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN44DeviceConnectivityReportDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DeviceConnectivityReportDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "ConnectivityReportDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<ConnectivityReportDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<DeviceConnectivityReportDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject DeviceConnectivityReportDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN44DeviceConnectivityReportDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN44DeviceConnectivityReportDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN44DeviceConnectivityReportDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int DeviceConnectivityReportDbusInterfaceFactory::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 < 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_ZN25ShareDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto ShareDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN25ShareDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ShareDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "ShareDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<ShareDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<ShareDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject ShareDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25ShareDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25ShareDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN25ShareDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int ShareDbusInterfaceFactory::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 < 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_ZN34VirtualmonitorDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto VirtualmonitorDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN34VirtualmonitorDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "VirtualmonitorDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "VirtualmonitorDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<VirtualmonitorDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<VirtualmonitorDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject VirtualmonitorDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN34VirtualmonitorDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN34VirtualmonitorDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN34VirtualmonitorDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int VirtualmonitorDbusInterfaceFactory::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 < 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_ZN24SftpDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto SftpDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN24SftpDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "SftpDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "SftpDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<SftpDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<SftpDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject SftpDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24SftpDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN24SftpDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN24SftpDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int SftpDbusInterfaceFactory::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 < 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_ZN23SmsDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto SmsDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN23SmsDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "SmsDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "SmsDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<SmsDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<SmsDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject SmsDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23SmsDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23SmsDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23SmsDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int SmsDbusInterfaceFactory::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 < 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_ZN29ClipboardDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto ClipboardDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN29ClipboardDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ClipboardDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "ClipboardDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<ClipboardDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<ClipboardDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject ClipboardDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29ClipboardDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN29ClipboardDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN29ClipboardDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int ClipboardDbusInterfaceFactory::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 < 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_ZN38RemoteSystemVolumeDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto RemoteSystemVolumeDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN38RemoteSystemVolumeDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RemoteSystemVolumeDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "RemoteSystemVolumeDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<RemoteSystemVolumeDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<RemoteSystemVolumeDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RemoteSystemVolumeDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN38RemoteSystemVolumeDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN38RemoteSystemVolumeDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN38RemoteSystemVolumeDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int RemoteSystemVolumeDbusInterfaceFactory::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 < 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_ZN34RemoteKeyboardDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto RemoteKeyboardDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN34RemoteKeyboardDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RemoteKeyboardDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "RemoteKeyboardDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<RemoteKeyboardDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<RemoteKeyboardDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RemoteKeyboardDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN34RemoteKeyboardDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN34RemoteKeyboardDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN34RemoteKeyboardDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int RemoteKeyboardDbusInterfaceFactory::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 < 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_ZN33RemoteControlDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto RemoteControlDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN33RemoteControlDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RemoteControlDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "RemoteControlDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<RemoteControlDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<RemoteControlDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RemoteControlDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33RemoteControlDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN33RemoteControlDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN33RemoteControlDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int RemoteControlDbusInterfaceFactory::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 < 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_ZN30LockDeviceDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto LockDeviceDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN30LockDeviceDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LockDeviceDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "LockDeviceDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<LockDeviceDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<LockDeviceDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject LockDeviceDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN30LockDeviceDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN30LockDeviceDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN30LockDeviceDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int LockDeviceDbusInterfaceFactory::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 < 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_ZN31FindMyPhoneDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto FindMyPhoneDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN31FindMyPhoneDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "FindMyPhoneDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "FindMyPhoneDeviceDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<FindMyPhoneDeviceDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<FindMyPhoneDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject FindMyPhoneDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31FindMyPhoneDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31FindMyPhoneDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN31FindMyPhoneDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int FindMyPhoneDbusInterfaceFactory::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 < 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_ZN34RemoteCommandsDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto RemoteCommandsDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN34RemoteCommandsDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RemoteCommandsDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "RemoteCommandsDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<RemoteCommandsDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<RemoteCommandsDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject RemoteCommandsDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN34RemoteCommandsDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN34RemoteCommandsDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN34RemoteCommandsDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int RemoteCommandsDbusInterfaceFactory::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 < 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_ZN25MprisDbusInterfaceFactoryE_t {};
} // unnamed namespace

template <> constexpr inline auto MprisDbusInterfaceFactory::qt_create_metaobjectdata<qt_meta_tag_ZN25MprisDbusInterfaceFactoryE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "MprisDbusInterfaceFactory",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "create",
        "MprisDbusInterface*",
        "",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'create'
        QtMocHelpers::MethodData<MprisDbusInterface *(const QString &)>(5, 7, QMC::AccessPublic, 0x80000000 | 6, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<MprisDbusInterfaceFactory, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject MprisDbusInterfaceFactory::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25MprisDbusInterfaceFactoryE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN25MprisDbusInterfaceFactoryE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN25MprisDbusInterfaceFactoryE_t>.metaTypes,
    nullptr
} };

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

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

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

int MprisDbusInterfaceFactory::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 < 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_ZN28AbstractPointerLockerForeignE_t {};
} // unnamed namespace

template <> constexpr inline auto AbstractPointerLockerForeign::qt_create_metaobjectdata<qt_meta_tag_ZN28AbstractPointerLockerForeignE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "AbstractPointerLockerForeign",
        "QML.Element",
        "PointerLocker",
        "QML.Foreign",
        "AbstractPointerLocker",
        "QML.Singleton",
        "true"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<AbstractPointerLockerForeign, void>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject AbstractPointerLockerForeign::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28AbstractPointerLockerForeignE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN28AbstractPointerLockerForeignE_t>.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN28AbstractPointerLockerForeignE_t>.metaTypes,
    nullptr
} };

namespace {
struct qt_meta_tag_ZN27KdeConnectDeclarativePluginE_t {};
} // unnamed namespace

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

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

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

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

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

int KdeConnectDeclarativePlugin::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QQmlExtensionPlugin::qt_metacall(_c, _id, _a);
    return _id;
}

#ifdef QT_MOC_EXPORT_PLUGIN_V2
static constexpr unsigned char qt_pluginMetaDataV2_KdeConnectDeclarativePlugin[] = {
    0xbf, 
    // "IID"
    0x02,  0x78,  0x28,  'o',  'r',  'g',  '.',  'q', 
    't',  '-',  'p',  'r',  'o',  'j',  'e',  'c', 
    't',  '.',  'Q',  't',  '.',  'Q',  'Q',  'm', 
    'l',  'E',  'x',  't',  'e',  'n',  's',  'i', 
    'o',  'n',  'I',  'n',  't',  'e',  'r',  'f', 
    'a',  'c',  'e', 
    // "className"
    0x03,  0x78,  0x1b,  'K',  'd',  'e',  'C',  'o', 
    'n',  'n',  'e',  'c',  't',  'D',  'e',  'c', 
    'l',  'a',  'r',  'a',  't',  'i',  'v',  'e', 
    'P',  'l',  'u',  'g',  'i',  'n', 
    // command-line "uri"
    0x63,  'u',  'r',  'i',  0x81,  0x72,  'o',  'r', 
    'g',  '.',  'k',  'd',  'e',  '.',  'k',  'd', 
    'e',  'c',  'o',  'n',  'n',  'e',  'c',  't', 
    0xff, 
};
QT_MOC_EXPORT_PLUGIN_V2(KdeConnectDeclarativePlugin, KdeConnectDeclarativePlugin, qt_pluginMetaDataV2_KdeConnectDeclarativePlugin)
#else
QT_PLUGIN_METADATA_SECTION
Q_CONSTINIT static constexpr unsigned char qt_pluginMetaData_KdeConnectDeclarativePlugin[] = {
    'Q', 'T', 'M', 'E', 'T', 'A', 'D', 'A', 'T', 'A', ' ', '!',
    // metadata version, Qt version, architectural requirements
    0, QT_VERSION_MAJOR, QT_VERSION_MINOR, qPluginArchRequirements(),
    0xbf, 
    // "IID"
    0x02,  0x78,  0x28,  'o',  'r',  'g',  '.',  'q', 
    't',  '-',  'p',  'r',  'o',  'j',  'e',  'c', 
    't',  '.',  'Q',  't',  '.',  'Q',  'Q',  'm', 
    'l',  'E',  'x',  't',  'e',  'n',  's',  'i', 
    'o',  'n',  'I',  'n',  't',  'e',  'r',  'f', 
    'a',  'c',  'e', 
    // "className"
    0x03,  0x78,  0x1b,  'K',  'd',  'e',  'C',  'o', 
    'n',  'n',  'e',  'c',  't',  'D',  'e',  'c', 
    'l',  'a',  'r',  'a',  't',  'i',  'v',  'e', 
    'P',  'l',  'u',  'g',  'i',  'n', 
    // command-line "uri"
    0x63,  'u',  'r',  'i',  0x81,  0x72,  'o',  'r', 
    'g',  '.',  'k',  'd',  'e',  '.',  'k',  'd', 
    'e',  'c',  'o',  'n',  'n',  'e',  'c',  't', 
    0xff, 
};
QT_MOC_EXPORT_PLUGIN(KdeConnectDeclarativePlugin, KdeConnectDeclarativePlugin)
#endif  // QT_MOC_EXPORT_PLUGIN_V2

QT_WARNING_POP
