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

#include "../../../../kdeconnect-kde-26.04.3/dbusinterfaces/dbusinterfaces.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


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

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto DaemonDbusInterface::qt_create_metaobjectdata<qt_meta_tag_ZN19DaemonDbusInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DaemonDbusInterface",
        "customDevicesChangedProxy",
        "",
        "customDevices"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'customDevicesChangedProxy'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'customDevices'
        QtMocHelpers::PropertyData<QStringList>(3, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DaemonDbusInterface, qt_meta_tag_ZN19DaemonDbusInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject DaemonDbusInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<OrgKdeKdeconnectDaemonInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19DaemonDbusInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19DaemonDbusInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19DaemonDbusInterfaceE_t>.metaTypes,
    nullptr
} };

void DaemonDbusInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DaemonDbusInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->customDevicesChangedProxy(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DaemonDbusInterface::*)()>(_a, &DaemonDbusInterface::customDevicesChangedProxy, 0))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QStringList*>(_v) = _t->customDevices(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setCustomDevices(*reinterpret_cast<QStringList*>(_v)); break;
        default: break;
        }
    }
}

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

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

int DaemonDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDaemonInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void DaemonDbusInterface::customDevicesChangedProxy()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN19DeviceDbusInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto DeviceDbusInterface::qt_create_metaobjectdata<qt_meta_tag_ZN19DeviceDbusInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DeviceDbusInterface",
        "nameChangedProxy",
        "",
        "name",
        "pairStateChangedProxy",
        "pairState",
        "reachableChangedProxy",
        "reachable",
        "id",
        "pluginCall",
        "plugin",
        "method",
        "isReachable",
        "isPaired",
        "isPairRequested",
        "isPairRequestedByPeer",
        "verificationKey"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'nameChangedProxy'
        QtMocHelpers::SignalData<void(const QString &)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'pairStateChangedProxy'
        QtMocHelpers::SignalData<void(int)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
        // Signal 'reachableChangedProxy'
        QtMocHelpers::SignalData<void(bool)>(6, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 7 },
        }}),
        // Method 'id'
        QtMocHelpers::MethodData<QString() const>(8, 2, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::QString),
        // Method 'pluginCall'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(9, 2, QMC::AccessPublic | QMC::MethodScriptable, QMetaType::Void, {{
            { QMetaType::QString, 10 }, { QMetaType::QString, 11 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'isReachable'
        QtMocHelpers::PropertyData<bool>(12, QMetaType::Bool, QMC::DefaultPropertyFlags, 2),
        // property 'isPaired'
        QtMocHelpers::PropertyData<bool>(13, QMetaType::Bool, QMC::DefaultPropertyFlags, 1),
        // property 'isPairRequested'
        QtMocHelpers::PropertyData<bool>(14, QMetaType::Bool, QMC::DefaultPropertyFlags, 1),
        // property 'isPairRequestedByPeer'
        QtMocHelpers::PropertyData<bool>(15, QMetaType::Bool, QMC::DefaultPropertyFlags, 1),
        // property 'pairState'
        QtMocHelpers::PropertyData<int>(5, QMetaType::Int, QMC::DefaultPropertyFlags, 1),
        // property 'name'
        QtMocHelpers::PropertyData<QString>(3, QMetaType::QString, QMC::DefaultPropertyFlags, 0),
        // property 'verificationKey'
        QtMocHelpers::PropertyData<QString>(16, QMetaType::QString, QMC::DefaultPropertyFlags, 1),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DeviceDbusInterface, qt_meta_tag_ZN19DeviceDbusInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject DeviceDbusInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<OrgKdeKdeconnectDeviceInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19DeviceDbusInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19DeviceDbusInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19DeviceDbusInterfaceE_t>.metaTypes,
    nullptr
} };

void DeviceDbusInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DeviceDbusInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->nameChangedProxy((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->pairStateChangedProxy((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 2: _t->reachableChangedProxy((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 3: { QString _r = _t->id();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 4: _t->pluginCall((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DeviceDbusInterface::*)(const QString & )>(_a, &DeviceDbusInterface::nameChangedProxy, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceDbusInterface::*)(int )>(_a, &DeviceDbusInterface::pairStateChangedProxy, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DeviceDbusInterface::*)(bool )>(_a, &DeviceDbusInterface::reachableChangedProxy, 2))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->isReachable(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->isPaired(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->isPairRequested(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->isPairRequestedByPeer(); break;
        case 4: *reinterpret_cast<int*>(_v) = _t->pairState(); break;
        case 5: *reinterpret_cast<QString*>(_v) = _t->name(); break;
        case 6: *reinterpret_cast<QString*>(_v) = _t->verificationKey(); break;
        default: break;
        }
    }
}

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

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

int DeviceDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 5;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 7;
    }
    return _id;
}

// SIGNAL 0
void DeviceDbusInterface::nameChangedProxy(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void DeviceDbusInterface::pairStateChangedProxy(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void DeviceDbusInterface::reachableChangedProxy(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN20BatteryDbusInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto BatteryDbusInterface::qt_create_metaobjectdata<qt_meta_tag_ZN20BatteryDbusInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "BatteryDbusInterface",
        "refreshedProxy",
        "",
        "isCharging",
        "charge"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'refreshedProxy'
        QtMocHelpers::SignalData<void(bool, int)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 }, { QMetaType::Int, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'charge'
        QtMocHelpers::PropertyData<int>(4, QMetaType::Int, QMC::DefaultPropertyFlags, 0),
        // property 'isCharging'
        QtMocHelpers::PropertyData<bool>(3, QMetaType::Bool, QMC::DefaultPropertyFlags, 0),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<BatteryDbusInterface, qt_meta_tag_ZN20BatteryDbusInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject BatteryDbusInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<OrgKdeKdeconnectDeviceBatteryInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20BatteryDbusInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN20BatteryDbusInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN20BatteryDbusInterfaceE_t>.metaTypes,
    nullptr
} };

void BatteryDbusInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<BatteryDbusInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->refreshedProxy((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (BatteryDbusInterface::*)(bool , int )>(_a, &BatteryDbusInterface::refreshedProxy, 0))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->charge(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->isCharging(); break;
        default: break;
        }
    }
}

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

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

int BatteryDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceBatteryInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    return _id;
}

// SIGNAL 0
void BatteryDbusInterface::refreshedProxy(bool _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}
namespace {
struct qt_meta_tag_ZN31ConnectivityReportDbusInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto ConnectivityReportDbusInterface::qt_create_metaobjectdata<qt_meta_tag_ZN31ConnectivityReportDbusInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ConnectivityReportDbusInterface",
        "refreshedProxy",
        "",
        "cellularNetworkType",
        "cellularNetworkStrength"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'refreshedProxy'
        QtMocHelpers::SignalData<void(QString, int)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 }, { QMetaType::Int, 4 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'cellularNetworkType'
        QtMocHelpers::PropertyData<QString>(3, QMetaType::QString, QMC::DefaultPropertyFlags, 0),
        // property 'cellularNetworkStrength'
        QtMocHelpers::PropertyData<int>(4, QMetaType::Int, QMC::DefaultPropertyFlags, 0),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ConnectivityReportDbusInterface, qt_meta_tag_ZN31ConnectivityReportDbusInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ConnectivityReportDbusInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<OrgKdeKdeconnectDeviceConnectivity_reportInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31ConnectivityReportDbusInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31ConnectivityReportDbusInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN31ConnectivityReportDbusInterfaceE_t>.metaTypes,
    nullptr
} };

void ConnectivityReportDbusInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ConnectivityReportDbusInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->refreshedProxy((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ConnectivityReportDbusInterface::*)(QString , int )>(_a, &ConnectivityReportDbusInterface::refreshedProxy, 0))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->cellularNetworkType(); break;
        case 1: *reinterpret_cast<int*>(_v) = _t->cellularNetworkStrength(); break;
        default: break;
        }
    }
}

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

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

int ConnectivityReportDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceConnectivity_reportInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    return _id;
}

// SIGNAL 0
void ConnectivityReportDbusInterface::refreshedProxy(QString _t1, int _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1, _t2);
}
namespace {
struct qt_meta_tag_ZN32DeviceNotificationsDbusInterfaceE_t {};
} // unnamed namespace

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

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

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

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

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

int DeviceNotificationsDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceNotificationsInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN25NotificationDbusInterfaceE_t {};
} // unnamed namespace

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

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

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

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

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

int NotificationDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceNotificationsNotificationInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN32DeviceConversationsDbusInterfaceE_t {};
} // unnamed namespace

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

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

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

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

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

int DeviceConversationsDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceConversationsInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN17SftpDbusInterfaceE_t {};
} // unnamed namespace

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

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

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

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

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

int SftpDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceSftpInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN18MprisDbusInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto MprisDbusInterface::qt_create_metaobjectdata<qt_meta_tag_ZN18MprisDbusInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "MprisDbusInterface",
        "propertiesChangedProxy",
        "",
        "isPlaying",
        "length",
        "title",
        "artist",
        "album",
        "localAlbumArtUrl",
        "playerList",
        "volume",
        "position",
        "canSeek"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'propertiesChangedProxy'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'isPlaying'
        QtMocHelpers::PropertyData<bool>(3, QMetaType::Bool, QMC::DefaultPropertyFlags, 0),
        // property 'length'
        QtMocHelpers::PropertyData<int>(4, QMetaType::Int, QMC::DefaultPropertyFlags, 0),
        // property 'title'
        QtMocHelpers::PropertyData<QString>(5, QMetaType::QString, QMC::DefaultPropertyFlags, 0),
        // property 'artist'
        QtMocHelpers::PropertyData<QString>(6, QMetaType::QString, QMC::DefaultPropertyFlags, 0),
        // property 'album'
        QtMocHelpers::PropertyData<QString>(7, QMetaType::QString, QMC::DefaultPropertyFlags, 0),
        // property 'localAlbumArtUrl'
        QtMocHelpers::PropertyData<QString>(8, QMetaType::QString, QMC::DefaultPropertyFlags, 0),
        // property 'playerList'
        QtMocHelpers::PropertyData<QStringList>(9, QMetaType::QStringList, QMC::DefaultPropertyFlags, 0),
        // property 'volume'
        QtMocHelpers::PropertyData<int>(10, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
        // property 'position'
        QtMocHelpers::PropertyData<int>(11, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
        // property 'canSeek'
        QtMocHelpers::PropertyData<bool>(12, QMetaType::Bool, QMC::DefaultPropertyFlags, 0),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<MprisDbusInterface, qt_meta_tag_ZN18MprisDbusInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject MprisDbusInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<OrgKdeKdeconnectDeviceMprisremoteInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18MprisDbusInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN18MprisDbusInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN18MprisDbusInterfaceE_t>.metaTypes,
    nullptr
} };

void MprisDbusInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<MprisDbusInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->propertiesChangedProxy(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (MprisDbusInterface::*)()>(_a, &MprisDbusInterface::propertiesChangedProxy, 0))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->isPlaying(); break;
        case 1: *reinterpret_cast<int*>(_v) = _t->length(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->title(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->artist(); break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->album(); break;
        case 5: *reinterpret_cast<QString*>(_v) = _t->localAlbumArtUrl(); break;
        case 6: *reinterpret_cast<QStringList*>(_v) = _t->playerList(); break;
        case 7: *reinterpret_cast<int*>(_v) = _t->volume(); break;
        case 8: *reinterpret_cast<int*>(_v) = _t->position(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->canSeek(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 7: _t->setVolume(*reinterpret_cast<int*>(_v)); break;
        case 8: _t->setPosition(*reinterpret_cast<int*>(_v)); break;
        default: break;
        }
    }
}

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

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

int MprisDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceMprisremoteInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 10;
    }
    return _id;
}

// SIGNAL 0
void MprisDbusInterface::propertiesChangedProxy()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN26RemoteControlDbusInterfaceE_t {};
} // unnamed namespace

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

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

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

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

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

int RemoteControlDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceRemotecontrolInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN23LockDeviceDbusInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto LockDeviceDbusInterface::qt_create_metaobjectdata<qt_meta_tag_ZN23LockDeviceDbusInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "LockDeviceDbusInterface",
        "lockedChangedProxy",
        "",
        "isLocked"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'lockedChangedProxy'
        QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'isLocked'
        QtMocHelpers::PropertyData<bool>(3, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<LockDeviceDbusInterface, qt_meta_tag_ZN23LockDeviceDbusInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject LockDeviceDbusInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<OrgKdeKdeconnectDeviceLockdeviceInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23LockDeviceDbusInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN23LockDeviceDbusInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN23LockDeviceDbusInterfaceE_t>.metaTypes,
    nullptr
} };

void LockDeviceDbusInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<LockDeviceDbusInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->lockedChangedProxy((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (LockDeviceDbusInterface::*)(bool )>(_a, &LockDeviceDbusInterface::lockedChangedProxy, 0))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->isLocked(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setIsLocked(*reinterpret_cast<bool*>(_v)); break;
        default: break;
        }
    }
}

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

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

int LockDeviceDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceLockdeviceInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void LockDeviceDbusInterface::lockedChangedProxy(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN30FindMyPhoneDeviceDbusInterfaceE_t {};
} // unnamed namespace

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

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

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

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

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

int FindMyPhoneDeviceDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceFindmyphoneInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN27RemoteCommandsDbusInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto RemoteCommandsDbusInterface::qt_create_metaobjectdata<qt_meta_tag_ZN27RemoteCommandsDbusInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RemoteCommandsDbusInterface",
        "deviceId",
        "canAddCommand"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'deviceId'
        QtMocHelpers::PropertyData<QString>(1, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'canAddCommand'
        QtMocHelpers::PropertyData<bool>(2, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<RemoteCommandsDbusInterface, qt_meta_tag_ZN27RemoteCommandsDbusInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject RemoteCommandsDbusInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<OrgKdeKdeconnectDeviceRemotecommandsInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27RemoteCommandsDbusInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27RemoteCommandsDbusInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27RemoteCommandsDbusInterfaceE_t>.metaTypes,
    nullptr
} };

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

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

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

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

template <> constexpr inline auto RemoteKeyboardDbusInterface::qt_create_metaobjectdata<qt_meta_tag_ZN27RemoteKeyboardDbusInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RemoteKeyboardDbusInterface",
        "remoteStateChangedProxy",
        "",
        "state",
        "remoteState"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'remoteStateChangedProxy'
        QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'remoteState'
        QtMocHelpers::PropertyData<bool>(4, QMetaType::Bool, QMC::DefaultPropertyFlags, 0),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<RemoteKeyboardDbusInterface, qt_meta_tag_ZN27RemoteKeyboardDbusInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject RemoteKeyboardDbusInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<OrgKdeKdeconnectDeviceRemotekeyboardInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27RemoteKeyboardDbusInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27RemoteKeyboardDbusInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27RemoteKeyboardDbusInterfaceE_t>.metaTypes,
    nullptr
} };

void RemoteKeyboardDbusInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<RemoteKeyboardDbusInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->remoteStateChangedProxy((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (RemoteKeyboardDbusInterface::*)(bool )>(_a, &RemoteKeyboardDbusInterface::remoteStateChangedProxy, 0))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->remoteState(); break;
        default: break;
        }
    }
}

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

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

int RemoteKeyboardDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceRemotekeyboardInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void RemoteKeyboardDbusInterface::remoteStateChangedProxy(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
namespace {
struct qt_meta_tag_ZN16SmsDbusInterfaceE_t {};
} // unnamed namespace

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

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

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

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

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

int SmsDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceSmsInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN18ShareDbusInterfaceE_t {};
} // unnamed namespace

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

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

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

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

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

int ShareDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceShareInterface::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN31RemoteSystemVolumeDbusInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto RemoteSystemVolumeDbusInterface::qt_create_metaobjectdata<qt_meta_tag_ZN31RemoteSystemVolumeDbusInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "RemoteSystemVolumeDbusInterface",
        "deviceId"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
        // property 'deviceId'
        QtMocHelpers::PropertyData<QString>(1, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<RemoteSystemVolumeDbusInterface, qt_meta_tag_ZN31RemoteSystemVolumeDbusInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject RemoteSystemVolumeDbusInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<OrgKdeKdeconnectDeviceRemotesystemvolumeInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31RemoteSystemVolumeDbusInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN31RemoteSystemVolumeDbusInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN31RemoteSystemVolumeDbusInterfaceE_t>.metaTypes,
    nullptr
} };

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

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

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

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

template <> constexpr inline auto VirtualmonitorDbusInterface::qt_create_metaobjectdata<qt_meta_tag_ZN27VirtualmonitorDbusInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "VirtualmonitorDbusInterface",
        "activeChanged",
        "",
        "active"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'activeChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'active'
        QtMocHelpers::PropertyData<bool>(3, QMetaType::Bool, QMC::DefaultPropertyFlags, 0),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<VirtualmonitorDbusInterface, qt_meta_tag_ZN27VirtualmonitorDbusInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject VirtualmonitorDbusInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<OrgKdeKdeconnectDeviceVirtualmonitorInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27VirtualmonitorDbusInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN27VirtualmonitorDbusInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN27VirtualmonitorDbusInterfaceE_t>.metaTypes,
    nullptr
} };

void VirtualmonitorDbusInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<VirtualmonitorDbusInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->activeChanged(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (VirtualmonitorDbusInterface::*)()>(_a, &VirtualmonitorDbusInterface::activeChanged, 0))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->active(); break;
        default: break;
        }
    }
}

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

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

int VirtualmonitorDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceVirtualmonitorInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void VirtualmonitorDbusInterface::activeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN22ClipboardDbusInterfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto ClipboardDbusInterface::qt_create_metaobjectdata<qt_meta_tag_ZN22ClipboardDbusInterfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "ClipboardDbusInterface",
        "autoShareDisabledChangedProxy",
        "",
        "b",
        "isAutoShareDisabled"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'autoShareDisabledChangedProxy'
        QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'isAutoShareDisabled'
        QtMocHelpers::PropertyData<bool>(4, QMetaType::Bool, QMC::DefaultPropertyFlags, 0),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<ClipboardDbusInterface, qt_meta_tag_ZN22ClipboardDbusInterfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject ClipboardDbusInterface::staticMetaObject = { {
    QMetaObject::SuperData::link<OrgKdeKdeconnectDeviceClipboardInterface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22ClipboardDbusInterfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN22ClipboardDbusInterfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN22ClipboardDbusInterfaceE_t>.metaTypes,
    nullptr
} };

void ClipboardDbusInterface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ClipboardDbusInterface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->autoShareDisabledChangedProxy((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ClipboardDbusInterface::*)(bool )>(_a, &ClipboardDbusInterface::autoShareDisabledChangedProxy, 0))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->isAutoShareDisabled(); break;
        default: break;
        }
    }
}

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

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

int ClipboardDbusInterface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OrgKdeKdeconnectDeviceClipboardInterface::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 1)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 1)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 1;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void ClipboardDbusInterface::autoShareDisabledChangedProxy(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}
QT_WARNING_POP
