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

#include "../../../../../../src/services/pipewire/qml.hpp"
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


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

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto qs::service::pipewire::PwObjectIface::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7service8pipewire13PwObjectIfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::service::pipewire::PwObjectIface",
        "onObjectDestroying",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onObjectDestroying'
        QtMocHelpers::SlotData<void()>(1, 2, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<PwObjectIface, qt_meta_tag_ZN2qs7service8pipewire13PwObjectIfaceE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject qs::service::pipewire::PwObjectIface::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire13PwObjectIfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire13PwObjectIfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7service8pipewire13PwObjectIfaceE_t>.metaTypes,
    nullptr
} };

void qs::service::pipewire::PwObjectIface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PwObjectIface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->onObjectDestroying(); break;
        default: ;
        }
    }
    (void)_a;
}

const QMetaObject *qs::service::pipewire::PwObjectIface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *qs::service::pipewire::PwObjectIface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire13PwObjectIfaceE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "PwObjectRefIface"))
        return static_cast< PwObjectRefIface*>(this);
    return QObject::qt_metacast(_clname);
}

int qs::service::pipewire::PwObjectIface::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_ZN2qs7service8pipewire8PipewireE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::service::pipewire::Pipewire::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7service8pipewire8PipewireE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::service::pipewire::Pipewire",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "defaultAudioSinkChanged",
        "",
        "defaultAudioSourceChanged",
        "defaultConfiguredAudioSinkChanged",
        "defaultConfiguredAudioSourceChanged",
        "readyChanged",
        "onNodeAdded",
        "PwNode*",
        "node",
        "onNodeRemoved",
        "object",
        "onLinkAdded",
        "PwLink*",
        "link",
        "onLinkRemoved",
        "onLinkGroupAdded",
        "PwLinkGroup*",
        "group",
        "onLinkGroupRemoved",
        "nodes",
        "UntypedObjectModel*",
        "links",
        "linkGroups",
        "defaultAudioSink",
        "qs::service::pipewire::PwNodeIface*",
        "defaultAudioSource",
        "preferredDefaultAudioSink",
        "preferredDefaultAudioSource",
        "ready"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'defaultAudioSinkChanged'
        QtMocHelpers::SignalData<void()>(5, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'defaultAudioSourceChanged'
        QtMocHelpers::SignalData<void()>(7, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'defaultConfiguredAudioSinkChanged'
        QtMocHelpers::SignalData<void()>(8, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'defaultConfiguredAudioSourceChanged'
        QtMocHelpers::SignalData<void()>(9, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'readyChanged'
        QtMocHelpers::SignalData<void()>(10, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onNodeAdded'
        QtMocHelpers::SlotData<void(PwNode *)>(11, 6, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 12, 13 },
        }}),
        // Slot 'onNodeRemoved'
        QtMocHelpers::SlotData<void(QObject *)>(14, 6, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QObjectStar, 15 },
        }}),
        // Slot 'onLinkAdded'
        QtMocHelpers::SlotData<void(PwLink *)>(16, 6, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 17, 18 },
        }}),
        // Slot 'onLinkRemoved'
        QtMocHelpers::SlotData<void(QObject *)>(19, 6, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QObjectStar, 15 },
        }}),
        // Slot 'onLinkGroupAdded'
        QtMocHelpers::SlotData<void(PwLinkGroup *)>(20, 6, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 21, 22 },
        }}),
        // Slot 'onLinkGroupRemoved'
        QtMocHelpers::SlotData<void(QObject *)>(23, 6, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QObjectStar, 15 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'nodes'
        QtMocHelpers::PropertyData<UntypedObjectModel*>(24, 0x80000000 | 25, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'links'
        QtMocHelpers::PropertyData<UntypedObjectModel*>(26, 0x80000000 | 25, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'linkGroups'
        QtMocHelpers::PropertyData<UntypedObjectModel*>(27, 0x80000000 | 25, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'defaultAudioSink'
        QtMocHelpers::PropertyData<qs::service::pipewire::PwNodeIface*>(28, 0x80000000 | 29, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
        // property 'defaultAudioSource'
        QtMocHelpers::PropertyData<qs::service::pipewire::PwNodeIface*>(30, 0x80000000 | 29, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
        // property 'preferredDefaultAudioSink'
        QtMocHelpers::PropertyData<qs::service::pipewire::PwNodeIface*>(31, 0x80000000 | 29, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 2),
        // property 'preferredDefaultAudioSource'
        QtMocHelpers::PropertyData<qs::service::pipewire::PwNodeIface*>(32, 0x80000000 | 29, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag, 3),
        // property 'ready'
        QtMocHelpers::PropertyData<bool>(33, QMetaType::Bool, QMC::DefaultPropertyFlags, 4),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
    });
    return QtMocHelpers::metaObjectData<Pipewire, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject qs::service::pipewire::Pipewire::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire8PipewireE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire8PipewireE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7service8pipewire8PipewireE_t>.metaTypes,
    nullptr
} };

void qs::service::pipewire::Pipewire::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Pipewire *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->defaultAudioSinkChanged(); break;
        case 1: _t->defaultAudioSourceChanged(); break;
        case 2: _t->defaultConfiguredAudioSinkChanged(); break;
        case 3: _t->defaultConfiguredAudioSourceChanged(); break;
        case 4: _t->readyChanged(); break;
        case 5: _t->onNodeAdded((*reinterpret_cast<std::add_pointer_t<PwNode*>>(_a[1]))); break;
        case 6: _t->onNodeRemoved((*reinterpret_cast<std::add_pointer_t<QObject*>>(_a[1]))); break;
        case 7: _t->onLinkAdded((*reinterpret_cast<std::add_pointer_t<PwLink*>>(_a[1]))); break;
        case 8: _t->onLinkRemoved((*reinterpret_cast<std::add_pointer_t<QObject*>>(_a[1]))); break;
        case 9: _t->onLinkGroupAdded((*reinterpret_cast<std::add_pointer_t<PwLinkGroup*>>(_a[1]))); break;
        case 10: _t->onLinkGroupRemoved((*reinterpret_cast<std::add_pointer_t<QObject*>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 5:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PwNode* >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PwLink* >(); break;
            }
            break;
        case 9:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PwLinkGroup* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Pipewire::*)()>(_a, &Pipewire::defaultAudioSinkChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Pipewire::*)()>(_a, &Pipewire::defaultAudioSourceChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Pipewire::*)()>(_a, &Pipewire::defaultConfiguredAudioSinkChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Pipewire::*)()>(_a, &Pipewire::defaultConfiguredAudioSourceChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Pipewire::*)()>(_a, &Pipewire::readyChanged, 4))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 2:
        case 1:
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< UntypedObjectModel* >(); break;
        case 6:
        case 5:
        case 4:
        case 3:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< qs::service::pipewire::PwNodeIface* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<UntypedObjectModel**>(_v) = _t->nodes(); break;
        case 1: *reinterpret_cast<UntypedObjectModel**>(_v) = _t->links(); break;
        case 2: *reinterpret_cast<UntypedObjectModel**>(_v) = _t->linkGroups(); break;
        case 3: *reinterpret_cast<qs::service::pipewire::PwNodeIface**>(_v) = _t->defaultAudioSink(); break;
        case 4: *reinterpret_cast<qs::service::pipewire::PwNodeIface**>(_v) = _t->defaultAudioSource(); break;
        case 5: *reinterpret_cast<qs::service::pipewire::PwNodeIface**>(_v) = _t->defaultConfiguredAudioSink(); break;
        case 6: *reinterpret_cast<qs::service::pipewire::PwNodeIface**>(_v) = _t->defaultConfiguredAudioSource(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->isReady(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 5: _t->setDefaultConfiguredAudioSink(*reinterpret_cast<qs::service::pipewire::PwNodeIface**>(_v)); break;
        case 6: _t->setDefaultConfiguredAudioSource(*reinterpret_cast<qs::service::pipewire::PwNodeIface**>(_v)); break;
        default: break;
        }
    }
}

const QMetaObject *qs::service::pipewire::Pipewire::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *qs::service::pipewire::Pipewire::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire8PipewireE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int qs::service::pipewire::Pipewire::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 < 11)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 11;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 11)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 11;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 8;
    }
    return _id;
}

// SIGNAL 0
void qs::service::pipewire::Pipewire::defaultAudioSinkChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void qs::service::pipewire::Pipewire::defaultAudioSourceChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void qs::service::pipewire::Pipewire::defaultConfiguredAudioSinkChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void qs::service::pipewire::Pipewire::defaultConfiguredAudioSourceChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void qs::service::pipewire::Pipewire::readyChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}
namespace {
struct qt_meta_tag_ZN2qs7service8pipewire17PwNodeLinkTrackerE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::service::pipewire::PwNodeLinkTracker::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7service8pipewire17PwNodeLinkTrackerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::service::pipewire::PwNodeLinkTracker",
        "QML.Element",
        "auto",
        "nodeChanged",
        "",
        "linkGroupsChanged",
        "onNodeDestroyed",
        "onLinkGroupCreated",
        "PwLinkGroup*",
        "linkGroup",
        "onLinkGroupDestroyed",
        "object",
        "node",
        "qs::service::pipewire::PwNodeIface*",
        "linkGroups",
        "QQmlListProperty<qs::service::pipewire::PwLinkGroupIface>"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'nodeChanged'
        QtMocHelpers::SignalData<void()>(3, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'linkGroupsChanged'
        QtMocHelpers::SignalData<void()>(5, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onNodeDestroyed'
        QtMocHelpers::SlotData<void()>(6, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onLinkGroupCreated'
        QtMocHelpers::SlotData<void(PwLinkGroup *)>(7, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 8, 9 },
        }}),
        // Slot 'onLinkGroupDestroyed'
        QtMocHelpers::SlotData<void(QObject *)>(10, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QObjectStar, 11 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'node'
        QtMocHelpers::PropertyData<qs::service::pipewire::PwNodeIface*>(12, 0x80000000 | 13, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
        // property 'linkGroups'
        QtMocHelpers::PropertyData<QQmlListProperty<qs::service::pipewire::PwLinkGroupIface>>(14, 0x80000000 | 15, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<PwNodeLinkTracker, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject qs::service::pipewire::PwNodeLinkTracker::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire17PwNodeLinkTrackerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire17PwNodeLinkTrackerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7service8pipewire17PwNodeLinkTrackerE_t>.metaTypes,
    nullptr
} };

void qs::service::pipewire::PwNodeLinkTracker::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PwNodeLinkTracker *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->nodeChanged(); break;
        case 1: _t->linkGroupsChanged(); break;
        case 2: _t->onNodeDestroyed(); break;
        case 3: _t->onLinkGroupCreated((*reinterpret_cast<std::add_pointer_t<PwLinkGroup*>>(_a[1]))); break;
        case 4: _t->onLinkGroupDestroyed((*reinterpret_cast<std::add_pointer_t<QObject*>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< PwLinkGroup* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PwNodeLinkTracker::*)()>(_a, &PwNodeLinkTracker::nodeChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (PwNodeLinkTracker::*)()>(_a, &PwNodeLinkTracker::linkGroupsChanged, 1))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< qs::service::pipewire::PwNodeIface* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<qs::service::pipewire::PwNodeIface**>(_v) = _t->node(); break;
        case 1: *reinterpret_cast<QQmlListProperty<qs::service::pipewire::PwLinkGroupIface>*>(_v) = _t->linkGroups(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setNode(*reinterpret_cast<qs::service::pipewire::PwNodeIface**>(_v)); break;
        default: break;
        }
    }
}

const QMetaObject *qs::service::pipewire::PwNodeLinkTracker::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *qs::service::pipewire::PwNodeLinkTracker::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire17PwNodeLinkTrackerE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int qs::service::pipewire::PwNodeLinkTracker::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 < 5)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 5;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 5)
            qt_static_metacall(this, _c, _id, _a);
        _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 -= 2;
    }
    return _id;
}

// SIGNAL 0
void qs::service::pipewire::PwNodeLinkTracker::nodeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void qs::service::pipewire::PwNodeLinkTracker::linkGroupsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}
namespace {
struct qt_meta_tag_ZN2qs7service8pipewire16PwNodeAudioIfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::service::pipewire::PwNodeAudioIface::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7service8pipewire16PwNodeAudioIfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::service::pipewire::PwNodeAudioIface",
        "QML.Element",
        "PwNodeAudio",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "PwNodeAudio cannot be created directly",
        "mutedChanged",
        "",
        "channelsChanged",
        "volumesChanged",
        "muted",
        "volume",
        "channels",
        "QList<qs::service::pipewire::PwAudioChannel::Enum>",
        "volumes",
        "QList<float>"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'mutedChanged'
        QtMocHelpers::SignalData<void()>(7, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'channelsChanged'
        QtMocHelpers::SignalData<void()>(9, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'volumesChanged'
        QtMocHelpers::SignalData<void()>(10, 8, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'muted'
        QtMocHelpers::PropertyData<bool>(11, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
        // property 'volume'
        QtMocHelpers::PropertyData<float>(12, QMetaType::Float, QMC::DefaultPropertyFlags | QMC::Writable, 2),
        // property 'channels'
        QtMocHelpers::PropertyData<QList<qs::service::pipewire::PwAudioChannel::Enum>>(13, 0x80000000 | 14, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 1),
        // property 'volumes'
        QtMocHelpers::PropertyData<QList<float>>(15, 0x80000000 | 16, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 2),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<PwNodeAudioIface, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject qs::service::pipewire::PwNodeAudioIface::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire16PwNodeAudioIfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire16PwNodeAudioIfaceE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7service8pipewire16PwNodeAudioIfaceE_t>.metaTypes,
    nullptr
} };

void qs::service::pipewire::PwNodeAudioIface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PwNodeAudioIface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->mutedChanged(); break;
        case 1: _t->channelsChanged(); break;
        case 2: _t->volumesChanged(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PwNodeAudioIface::*)()>(_a, &PwNodeAudioIface::mutedChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (PwNodeAudioIface::*)()>(_a, &PwNodeAudioIface::channelsChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (PwNodeAudioIface::*)()>(_a, &PwNodeAudioIface::volumesChanged, 2))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 3:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<float> >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->isMuted(); break;
        case 1: *reinterpret_cast<float*>(_v) = _t->averageVolume(); break;
        case 2: *reinterpret_cast<QList<qs::service::pipewire::PwAudioChannel::Enum>*>(_v) = _t->channels(); break;
        case 3: *reinterpret_cast<QList<float>*>(_v) = _t->volumes(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setMuted(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->setAverageVolume(*reinterpret_cast<float*>(_v)); break;
        case 3: _t->setVolumes(*reinterpret_cast<QList<float>*>(_v)); break;
        default: break;
        }
    }
}

const QMetaObject *qs::service::pipewire::PwNodeAudioIface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *qs::service::pipewire::PwNodeAudioIface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire16PwNodeAudioIfaceE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

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

// SIGNAL 0
void qs::service::pipewire::PwNodeAudioIface::mutedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void qs::service::pipewire::PwNodeAudioIface::channelsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void qs::service::pipewire::PwNodeAudioIface::volumesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}
namespace {
struct qt_meta_tag_ZN2qs7service8pipewire11PwNodeIfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::service::pipewire::PwNodeIface::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7service8pipewire11PwNodeIfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::service::pipewire::PwNodeIface",
        "QML.Element",
        "PwNode",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "PwNodes cannot be created directly",
        "propertiesChanged",
        "",
        "readyChanged",
        "id",
        "name",
        "description",
        "nickname",
        "isSink",
        "isStream",
        "type",
        "qs::service::pipewire::PwNodeType::Flags",
        "properties",
        "QVariantMap",
        "audio",
        "qs::service::pipewire::PwNodeAudioIface*",
        "ready"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'propertiesChanged'
        QtMocHelpers::SignalData<void()>(7, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'readyChanged'
        QtMocHelpers::SignalData<void()>(9, 8, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'id'
        QtMocHelpers::PropertyData<quint32>(10, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'name'
        QtMocHelpers::PropertyData<QString>(11, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'description'
        QtMocHelpers::PropertyData<QString>(12, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'nickname'
        QtMocHelpers::PropertyData<QString>(13, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'isSink'
        QtMocHelpers::PropertyData<bool>(14, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'isStream'
        QtMocHelpers::PropertyData<bool>(15, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'type'
        QtMocHelpers::PropertyData<qs::service::pipewire::PwNodeType::Flags>(16, 0x80000000 | 17, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'properties'
        QtMocHelpers::PropertyData<QVariantMap>(18, 0x80000000 | 19, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
        // property 'audio'
        QtMocHelpers::PropertyData<qs::service::pipewire::PwNodeAudioIface*>(20, 0x80000000 | 21, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'ready'
        QtMocHelpers::PropertyData<bool>(22, QMetaType::Bool, QMC::DefaultPropertyFlags, 1),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<PwNodeIface, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN2qs7service8pipewire11PwNodeIfaceE[] = {
    QMetaObject::SuperData::link<qs::service::pipewire::PwNodeType::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject qs::service::pipewire::PwNodeIface::staticMetaObject = { {
    QMetaObject::SuperData::link<PwObjectIface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire11PwNodeIfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire11PwNodeIfaceE_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN2qs7service8pipewire11PwNodeIfaceE,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7service8pipewire11PwNodeIfaceE_t>.metaTypes,
    nullptr
} };

void qs::service::pipewire::PwNodeIface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PwNodeIface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->propertiesChanged(); break;
        case 1: _t->readyChanged(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PwNodeIface::*)()>(_a, &PwNodeIface::propertiesChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (PwNodeIface::*)()>(_a, &PwNodeIface::readyChanged, 1))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 8:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< qs::service::pipewire::PwNodeAudioIface* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<quint32*>(_v) = _t->id(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->name(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->description(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->nickname(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->isSink(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->isStream(); break;
        case 6: *reinterpret_cast<qs::service::pipewire::PwNodeType::Flags*>(_v) = _t->type(); break;
        case 7: *reinterpret_cast<QVariantMap*>(_v) = _t->properties(); break;
        case 8: *reinterpret_cast<qs::service::pipewire::PwNodeAudioIface**>(_v) = _t->audio(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->isReady(); break;
        default: break;
        }
    }
}

const QMetaObject *qs::service::pipewire::PwNodeIface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *qs::service::pipewire::PwNodeIface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire11PwNodeIfaceE_t>.strings))
        return static_cast<void*>(this);
    return PwObjectIface::qt_metacast(_clname);
}

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

// SIGNAL 0
void qs::service::pipewire::PwNodeIface::propertiesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void qs::service::pipewire::PwNodeIface::readyChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}
namespace {
struct qt_meta_tag_ZN2qs7service8pipewire11PwLinkIfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::service::pipewire::PwLinkIface::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7service8pipewire11PwLinkIfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::service::pipewire::PwLinkIface",
        "QML.Element",
        "PwLink",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "PwLinks cannot be created directly",
        "stateChanged",
        "",
        "id",
        "target",
        "qs::service::pipewire::PwNodeIface*",
        "source",
        "state",
        "PwLinkState::Enum"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'stateChanged'
        QtMocHelpers::SignalData<void()>(7, 8, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'id'
        QtMocHelpers::PropertyData<quint32>(9, QMetaType::UInt, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'target'
        QtMocHelpers::PropertyData<qs::service::pipewire::PwNodeIface*>(10, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'source'
        QtMocHelpers::PropertyData<qs::service::pipewire::PwNodeIface*>(12, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'state'
        QtMocHelpers::PropertyData<PwLinkState::Enum>(13, 0x80000000 | 14, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<PwLinkIface, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN2qs7service8pipewire11PwLinkIfaceE[] = {
    QMetaObject::SuperData::link<qs::service::pipewire::PwLinkState::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject qs::service::pipewire::PwLinkIface::staticMetaObject = { {
    QMetaObject::SuperData::link<PwObjectIface::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire11PwLinkIfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire11PwLinkIfaceE_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN2qs7service8pipewire11PwLinkIfaceE,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7service8pipewire11PwLinkIfaceE_t>.metaTypes,
    nullptr
} };

void qs::service::pipewire::PwLinkIface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PwLinkIface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->stateChanged(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PwLinkIface::*)()>(_a, &PwLinkIface::stateChanged, 0))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 2:
        case 1:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< qs::service::pipewire::PwNodeIface* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<quint32*>(_v) = _t->id(); break;
        case 1: *reinterpret_cast<qs::service::pipewire::PwNodeIface**>(_v) = _t->target(); break;
        case 2: *reinterpret_cast<qs::service::pipewire::PwNodeIface**>(_v) = _t->source(); break;
        case 3: *reinterpret_cast<PwLinkState::Enum*>(_v) = _t->state(); break;
        default: break;
        }
    }
}

const QMetaObject *qs::service::pipewire::PwLinkIface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *qs::service::pipewire::PwLinkIface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire11PwLinkIfaceE_t>.strings))
        return static_cast<void*>(this);
    return PwObjectIface::qt_metacast(_clname);
}

int qs::service::pipewire::PwLinkIface::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = PwObjectIface::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 -= 4;
    }
    return _id;
}

// SIGNAL 0
void qs::service::pipewire::PwLinkIface::stateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN2qs7service8pipewire16PwLinkGroupIfaceE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::service::pipewire::PwLinkGroupIface::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7service8pipewire16PwLinkGroupIfaceE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::service::pipewire::PwLinkGroupIface",
        "QML.Element",
        "PwLinkGroup",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "PwLinkGroups cannot be created directly",
        "stateChanged",
        "",
        "target",
        "qs::service::pipewire::PwNodeIface*",
        "source",
        "state",
        "qs::service::pipewire::PwLinkState::Enum"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'stateChanged'
        QtMocHelpers::SignalData<void()>(7, 8, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'target'
        QtMocHelpers::PropertyData<qs::service::pipewire::PwNodeIface*>(9, 0x80000000 | 10, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'source'
        QtMocHelpers::PropertyData<qs::service::pipewire::PwNodeIface*>(11, 0x80000000 | 10, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'state'
        QtMocHelpers::PropertyData<qs::service::pipewire::PwLinkState::Enum>(12, 0x80000000 | 13, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<PwLinkGroupIface, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN2qs7service8pipewire16PwLinkGroupIfaceE[] = {
    QMetaObject::SuperData::link<qs::service::pipewire::PwLinkState::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject qs::service::pipewire::PwLinkGroupIface::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire16PwLinkGroupIfaceE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire16PwLinkGroupIfaceE_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN2qs7service8pipewire16PwLinkGroupIfaceE,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7service8pipewire16PwLinkGroupIfaceE_t>.metaTypes,
    nullptr
} };

void qs::service::pipewire::PwLinkGroupIface::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PwLinkGroupIface *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->stateChanged(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PwLinkGroupIface::*)()>(_a, &PwLinkGroupIface::stateChanged, 0))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 1:
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< qs::service::pipewire::PwNodeIface* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<qs::service::pipewire::PwNodeIface**>(_v) = _t->target(); break;
        case 1: *reinterpret_cast<qs::service::pipewire::PwNodeIface**>(_v) = _t->source(); break;
        case 2: *reinterpret_cast<qs::service::pipewire::PwLinkState::Enum*>(_v) = _t->state(); break;
        default: break;
        }
    }
}

const QMetaObject *qs::service::pipewire::PwLinkGroupIface::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *qs::service::pipewire::PwLinkGroupIface::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire16PwLinkGroupIfaceE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "PwObjectRefIface"))
        return static_cast< PwObjectRefIface*>(this);
    return QObject::qt_metacast(_clname);
}

int qs::service::pipewire::PwLinkGroupIface::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;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 3;
    }
    return _id;
}

// SIGNAL 0
void qs::service::pipewire::PwLinkGroupIface::stateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
namespace {
struct qt_meta_tag_ZN2qs7service8pipewire15PwObjectTrackerE_t {};
} // unnamed namespace

template <> constexpr inline auto qs::service::pipewire::PwObjectTracker::qt_create_metaobjectdata<qt_meta_tag_ZN2qs7service8pipewire15PwObjectTrackerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qs::service::pipewire::PwObjectTracker",
        "QML.Element",
        "auto",
        "objectsChanged",
        "",
        "objectDestroyed",
        "object",
        "objects",
        "QList<QObject*>"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'objectsChanged'
        QtMocHelpers::SignalData<void()>(3, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'objectDestroyed'
        QtMocHelpers::SlotData<void(QObject *)>(5, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QObjectStar, 6 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'objects'
        QtMocHelpers::PropertyData<QList<QObject*>>(7, 0x80000000 | 8, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 0),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<PwObjectTracker, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject qs::service::pipewire::PwObjectTracker::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire15PwObjectTrackerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire15PwObjectTrackerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN2qs7service8pipewire15PwObjectTrackerE_t>.metaTypes,
    nullptr
} };

void qs::service::pipewire::PwObjectTracker::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PwObjectTracker *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->objectsChanged(); break;
        case 1: _t->objectDestroyed((*reinterpret_cast<std::add_pointer_t<QObject*>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PwObjectTracker::*)()>(_a, &PwObjectTracker::objectsChanged, 0))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QList<QObject*> >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QList<QObject*>*>(_v) = _t->objects(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setObjects(*reinterpret_cast<QList<QObject*>*>(_v)); break;
        default: break;
        }
    }
}

const QMetaObject *qs::service::pipewire::PwObjectTracker::metaObject() const
{
    return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}

void *qs::service::pipewire::PwObjectTracker::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN2qs7service8pipewire15PwObjectTrackerE_t>.strings))
        return static_cast<void*>(this);
    return QObject::qt_metacast(_clname);
}

int qs::service::pipewire::PwObjectTracker::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 < 2)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 2;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 2)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 2;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 1;
    }
    return _id;
}

// SIGNAL 0
void qs::service::pipewire::PwObjectTracker::objectsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}
QT_WARNING_POP
