/****************************************************************************
** Meta object code from reading C++ file 'qt_options.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 "../../../../../ui/drivers/qt/qt_options.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 'qt_options.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_ZN11OptionsPageE_t {};
} // unnamed namespace

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

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

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

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

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

int OptionsPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN15OptionsCategoryE_t {};
} // unnamed namespace

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

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

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

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

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

int OptionsCategory::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QObject::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN11DriversPageE_t {};
} // unnamed namespace

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

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

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

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

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

int DriversPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13AIServicePageE_t {};
} // unnamed namespace

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

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

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

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

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

int AIServicePage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN22AspectRatioRadioButtonE_t {};
} // unnamed namespace

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

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

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

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

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

int AspectRatioRadioButton::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QRadioButton::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN16AspectRatioGroupE_t {};
} // unnamed namespace

template <> constexpr inline auto AspectRatioGroup::qt_create_metaobjectdata<qt_meta_tag_ZN16AspectRatioGroupE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "AspectRatioGroup",
        "paintEvent",
        "",
        "QPaintEvent*",
        "event",
        "onAspectRadioToggled",
        "checked",
        "onAspectRadioClicked"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'paintEvent'
        QtMocHelpers::SlotData<void(QPaintEvent *)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 3, 4 },
        }}),
        // Slot 'onAspectRadioToggled'
        QtMocHelpers::SlotData<void(bool)>(5, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 6 },
        }}),
        // Slot 'onAspectRadioClicked'
        QtMocHelpers::SlotData<void(bool)>(7, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 6 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<AspectRatioGroup, qt_meta_tag_ZN16AspectRatioGroupE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject AspectRatioGroup::staticMetaObject = { {
    QMetaObject::SuperData::link<SettingsGroup::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16AspectRatioGroupE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16AspectRatioGroupE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16AspectRatioGroupE_t>.metaTypes,
    nullptr
} };

void AspectRatioGroup::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<AspectRatioGroup *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->paintEvent((*reinterpret_cast<std::add_pointer_t<QPaintEvent*>>(_a[1]))); break;
        case 1: _t->onAspectRadioToggled((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->onAspectRadioClicked((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        default: ;
        }
    }
}

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

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

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

template <> constexpr inline auto VideoPage::qt_create_metaobjectdata<qt_meta_tag_ZN9VideoPageE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "VideoPage",
        "onResolutionComboIndexChanged",
        "Q_DECL_DEPRECATED",
        "value",
        "",
        "index"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onResolutionComboIndexChanged'
        QtMocHelpers::SlotData<void(const QString &)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Slot 'onResolutionComboIndexChanged'
        QtMocHelpers::SlotData<void(int)>(1, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 5 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<VideoPage, qt_meta_tag_ZN9VideoPageE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject VideoPage::staticMetaObject = { {
    QMetaObject::SuperData::link<OptionsPage::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9VideoPageE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN9VideoPageE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN9VideoPageE_t>.metaTypes,
    nullptr
} };

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

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

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

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

template <> constexpr inline auto CrtSwitchresPage::qt_create_metaobjectdata<qt_meta_tag_ZN16CrtSwitchresPageE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "CrtSwitchresPage",
        "onCrtSuperResolutionComboIndexChanged",
        "",
        "index"
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onCrtSuperResolutionComboIndexChanged'
        QtMocHelpers::SlotData<void(int)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 3 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<CrtSwitchresPage, qt_meta_tag_ZN16CrtSwitchresPageE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject CrtSwitchresPage::staticMetaObject = { {
    QMetaObject::SuperData::link<OptionsPage::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16CrtSwitchresPageE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16CrtSwitchresPageE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16CrtSwitchresPageE_t>.metaTypes,
    nullptr
} };

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

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

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

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

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

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

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

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

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

int AudioPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN14MenuSoundsPageE_t {};
} // unnamed namespace

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

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

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

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

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

int MenuSoundsPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN9InputPageE_t {};
} // unnamed namespace

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

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

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

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

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

int InputPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN15HotkeyBindsPageE_t {};
} // unnamed namespace

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

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

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

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

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

int HotkeyBindsPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13UserBindsPageE_t {};
} // unnamed namespace

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

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

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

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

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

int UserBindsPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN11LatencyPageE_t {};
} // unnamed namespace

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

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

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

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

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

int LatencyPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN8CorePageE_t {};
} // unnamed namespace

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

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

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

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

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

int CorePage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN17ConfigurationPageE_t {};
} // unnamed namespace

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

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

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

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

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

int ConfigurationPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN10SavingPageE_t {};
} // unnamed namespace

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

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

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

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

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

int SavingPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN11LoggingPageE_t {};
} // unnamed namespace

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

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

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

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

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

int LoggingPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN17FrameThrottlePageE_t {};
} // unnamed namespace

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

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

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

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

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

int FrameThrottlePage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN10RewindPageE_t {};
} // unnamed namespace

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

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

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

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

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

int RewindPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13RecordingPageE_t {};
} // unnamed namespace

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

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

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

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

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

int RecordingPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN17UserInterfacePageE_t {};
} // unnamed namespace

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

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

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

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

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

int UserInterfacePage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN9ViewsPageE_t {};
} // unnamed namespace

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

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

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

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

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

int ViewsPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13QuickMenuPageE_t {};
} // unnamed namespace

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

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

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

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

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

int QuickMenuPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN14AppearancePageE_t {};
} // unnamed namespace

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

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

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

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

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

int AppearancePage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN15DesktopMenuPageE_t {};
} // unnamed namespace

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

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

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

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

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

int DesktopMenuPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN11OverlayPageE_t {};
} // unnamed namespace

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

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

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

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

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

int OverlayPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN17NotificationsPageE_t {};
} // unnamed namespace

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

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

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

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

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

int NotificationsPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN16AchievementsPageE_t {};
} // unnamed namespace

template <> constexpr inline auto AchievementsPage::qt_create_metaobjectdata<qt_meta_tag_ZN16AchievementsPageE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "AchievementsPage",
        "onAchievementEnabledChanged",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onAchievementEnabledChanged'
        QtMocHelpers::SlotData<void(int)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<AchievementsPage, qt_meta_tag_ZN16AchievementsPageE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject AchievementsPage::staticMetaObject = { {
    QMetaObject::SuperData::link<OptionsPage::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16AchievementsPageE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN16AchievementsPageE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN16AchievementsPageE_t>.metaTypes,
    nullptr
} };

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

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

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

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

template <> constexpr inline auto NetplayPage::qt_create_metaobjectdata<qt_meta_tag_ZN11NetplayPageE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "NetplayPage",
        "onRadioButtonClicked",
        ""
    };

    QtMocHelpers::UintData qt_methods {
        // Slot 'onRadioButtonClicked'
        QtMocHelpers::SlotData<void(int)>(1, 2, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 2 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<NetplayPage, qt_meta_tag_ZN11NetplayPageE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject NetplayPage::staticMetaObject = { {
    QMetaObject::SuperData::link<OptionsPage::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11NetplayPageE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11NetplayPageE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11NetplayPageE_t>.metaTypes,
    nullptr
} };

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

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

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

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

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

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

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

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

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

int UpdaterPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13PlaylistsPageE_t {};
} // unnamed namespace

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

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

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

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

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

int PlaylistsPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN12AccountsPageE_t {};
} // unnamed namespace

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

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

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

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

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

int AccountsPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN8UserPageE_t {};
} // unnamed namespace

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

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

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

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

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

int UserPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
namespace {
struct qt_meta_tag_ZN13DirectoryPageE_t {};
} // unnamed namespace

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

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

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

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

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

int DirectoryPage::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = OptionsPage::qt_metacall(_c, _id, _a);
    return _id;
}
QT_WARNING_POP
