/****************************************************************************
** Meta object code from reading C++ file 'ApplicationModel.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 "../../../../../../AusweisApp-2.5.1/src/ui/qml/ApplicationModel.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 'ApplicationModel.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_ZN10governikus16ApplicationModelE_t {};
} // unnamed namespace

template <> constexpr inline auto governikus::ApplicationModel::qt_create_metaobjectdata<qt_meta_tag_ZN10governikus16ApplicationModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "governikus::ApplicationModel",
        "RegisterEnumClassesUnscoped",
        "false",
        "QML.Element",
        "auto",
        "QML.Singleton",
        "true",
        "fireAppAboutToQuit",
        "",
        "fireStoreUrlChanged",
        "fireNfcStateChanged",
        "fireReaderPropertiesUpdated",
        "fireCurrentWorkflowChanged",
        "fireAvailableReaderChanged",
        "fireWifiEnabledChanged",
        "fireFeedbackChanged",
        "fireApplicationStateChanged",
        "pIsAppInForeground",
        "fireScreenReaderRunningChanged",
        "fireA11yFocusChanged",
        "QQuickItem*",
        "pItem",
        "fireScreenRecordingChanged",
        "fireScreenshotTaken",
        "onApplicationStateChanged",
        "Qt::ApplicationState",
        "pState",
        "onWifiEnabledChanged",
        "onTranslationChanged",
        "onShowNextFeedback",
        "randomInt",
        "pLowerBound",
        "pUpperBound",
        "enableWifi",
        "setClipboardText",
        "pText",
        "showSettings",
        "Settings",
        "pAction",
        "showFeedback",
        "pMessage",
        "pReplaceExisting",
        "keepScreenOn",
        "pActive",
        "preventScreenshot",
        "pPrevent",
        "getLicenseText",
        "getCustomConfigPath",
        "QUrl",
        "saveEmbeddedConfig",
        "pFilename",
        "stripHtmlTags",
        "pString",
        "showAppStoreRatingDialog",
        "storeUrl",
        "nfcState",
        "NfcState",
        "extendedLengthApdusUnsupported",
        "wifiEnabled",
        "currentWorkflow",
        "Workflow",
        "availablePcscReader",
        "qsizetype",
        "availableRemoteReader",
        "usedPluginType",
        "governikus::EnumReaderManagerPluginType::ReaderManagerPluginType",
        "feedback",
        "feedbackTimeout",
        "screenReaderRunning",
        "screenRecording",
        "customConfigPath",
        "WIFI",
        "NETWORK",
        "NFC",
        "APP",
        "CHANGE_PIN",
        "SELF_AUTHENTICATION",
        "AUTHENTICATION",
        "REMOTE_SERVICE",
        "NONE",
        "UNAVAILABLE",
        "DISABLED",
        "INACTIVE",
        "READY"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'fireAppAboutToQuit'
        QtMocHelpers::SignalData<void()>(7, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fireStoreUrlChanged'
        QtMocHelpers::SignalData<void()>(9, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fireNfcStateChanged'
        QtMocHelpers::SignalData<void()>(10, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fireReaderPropertiesUpdated'
        QtMocHelpers::SignalData<void()>(11, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fireCurrentWorkflowChanged'
        QtMocHelpers::SignalData<void()>(12, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fireAvailableReaderChanged'
        QtMocHelpers::SignalData<void()>(13, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fireWifiEnabledChanged'
        QtMocHelpers::SignalData<void()>(14, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fireFeedbackChanged'
        QtMocHelpers::SignalData<void()>(15, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fireApplicationStateChanged'
        QtMocHelpers::SignalData<void(bool)>(16, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'fireScreenReaderRunningChanged'
        QtMocHelpers::SignalData<void()>(18, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fireA11yFocusChanged'
        QtMocHelpers::SignalData<void(QQuickItem *)>(19, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 20, 21 },
        }}),
        // Signal 'fireScreenRecordingChanged'
        QtMocHelpers::SignalData<void()>(22, 8, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fireScreenshotTaken'
        QtMocHelpers::SignalData<void()>(23, 8, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onApplicationStateChanged'
        QtMocHelpers::SlotData<void(Qt::ApplicationState)>(24, 8, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 25, 26 },
        }}),
        // Slot 'onWifiEnabledChanged'
        QtMocHelpers::SlotData<void()>(27, 8, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onTranslationChanged'
        QtMocHelpers::SlotData<void()>(28, 8, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onShowNextFeedback'
        QtMocHelpers::SlotData<void()>(29, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'randomInt'
        QtMocHelpers::MethodData<int(int, int) const>(30, 8, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 31 }, { QMetaType::Int, 32 },
        }}),
        // Method 'enableWifi'
        QtMocHelpers::MethodData<void() const>(33, 8, QMC::AccessPublic, QMetaType::Void),
        // Method 'setClipboardText'
        QtMocHelpers::MethodData<void(const QString &) const>(34, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 35 },
        }}),
        // Method 'showSettings'
        QtMocHelpers::MethodData<void(const Settings &) const>(36, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 37, 38 },
        }}),
        // Method 'showFeedback'
        QtMocHelpers::MethodData<void(const QString &, bool)>(39, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 40 }, { QMetaType::Bool, 41 },
        }}),
        // Method 'showFeedback'
        QtMocHelpers::MethodData<void(const QString &)>(39, 8, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 40 },
        }}),
        // Method 'keepScreenOn'
        QtMocHelpers::MethodData<void(bool) const>(42, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 43 },
        }}),
        // Method 'preventScreenshot'
        QtMocHelpers::MethodData<void(bool) const>(44, 8, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 45 },
        }}),
        // Method 'getLicenseText'
        QtMocHelpers::MethodData<QStringList() const>(46, 8, QMC::AccessPublic, QMetaType::QStringList),
        // Method 'getCustomConfigPath'
        QtMocHelpers::MethodData<QUrl() const>(47, 8, QMC::AccessPublic, 0x80000000 | 48),
        // Method 'saveEmbeddedConfig'
        QtMocHelpers::MethodData<void(const QUrl &) const>(49, 8, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 48, 50 },
        }}),
        // Method 'stripHtmlTags'
        QtMocHelpers::MethodData<QString(QString) const>(51, 8, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 52 },
        }}),
        // Method 'showAppStoreRatingDialog'
        QtMocHelpers::MethodData<void() const>(53, 8, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'storeUrl'
        QtMocHelpers::PropertyData<QString>(54, QMetaType::QString, QMC::DefaultPropertyFlags, 1),
        // property 'nfcState'
        QtMocHelpers::PropertyData<enum NfcState>(55, 0x80000000 | 56, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 2),
        // property 'extendedLengthApdusUnsupported'
        QtMocHelpers::PropertyData<bool>(57, QMetaType::Bool, QMC::DefaultPropertyFlags, 3),
        // property 'wifiEnabled'
        QtMocHelpers::PropertyData<bool>(58, QMetaType::Bool, QMC::DefaultPropertyFlags, 6),
        // property 'currentWorkflow'
        QtMocHelpers::PropertyData<enum Workflow>(59, 0x80000000 | 60, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 4),
        // property 'availablePcscReader'
        QtMocHelpers::PropertyData<qsizetype>(61, 0x80000000 | 62, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 5),
        // property 'availableRemoteReader'
        QtMocHelpers::PropertyData<qsizetype>(63, 0x80000000 | 62, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 5),
        // property 'usedPluginType'
        QtMocHelpers::PropertyData<governikus::EnumReaderManagerPluginType::ReaderManagerPluginType>(64, 0x80000000 | 65, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 5),
        // property 'feedback'
        QtMocHelpers::PropertyData<QString>(66, QMetaType::QString, QMC::DefaultPropertyFlags, 7),
        // property 'feedbackTimeout'
        QtMocHelpers::PropertyData<int>(67, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'screenReaderRunning'
        QtMocHelpers::PropertyData<bool>(68, QMetaType::Bool, QMC::DefaultPropertyFlags, 9),
        // property 'screenRecording'
        QtMocHelpers::PropertyData<bool>(69, QMetaType::Bool, QMC::DefaultPropertyFlags, 11),
        // property 'customConfigPath'
        QtMocHelpers::PropertyData<QUrl>(70, 0x80000000 | 48, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Settings'
        QtMocHelpers::EnumData<enum Settings>(37, 37, QMC::EnumIsScoped).add({
            {   71, Settings::WIFI },
            {   72, Settings::NETWORK },
            {   73, Settings::NFC },
            {   74, Settings::APP },
        }),
        // enum 'Workflow'
        QtMocHelpers::EnumData<enum Workflow>(60, 60, QMC::EnumIsScoped).add({
            {   75, Workflow::CHANGE_PIN },
            {   76, Workflow::SELF_AUTHENTICATION },
            {   77, Workflow::AUTHENTICATION },
            {   78, Workflow::REMOTE_SERVICE },
            {   79, Workflow::NONE },
        }),
        // enum 'NfcState'
        QtMocHelpers::EnumData<enum NfcState>(56, 56, QMC::EnumIsScoped).add({
            {   80, NfcState::UNAVAILABLE },
            {   81, NfcState::DISABLED },
            {   82, NfcState::INACTIVE },
            {   83, NfcState::READY },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<ApplicationModel, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN10governikus16ApplicationModelE[] = {
    QMetaObject::SuperData::link<governikus::EnumReaderManagerPluginType::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject governikus::ApplicationModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10governikus16ApplicationModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10governikus16ApplicationModelE_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN10governikus16ApplicationModelE,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN10governikus16ApplicationModelE_t>.metaTypes,
    nullptr
} };

void governikus::ApplicationModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<ApplicationModel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->fireAppAboutToQuit(); break;
        case 1: _t->fireStoreUrlChanged(); break;
        case 2: _t->fireNfcStateChanged(); break;
        case 3: _t->fireReaderPropertiesUpdated(); break;
        case 4: _t->fireCurrentWorkflowChanged(); break;
        case 5: _t->fireAvailableReaderChanged(); break;
        case 6: _t->fireWifiEnabledChanged(); break;
        case 7: _t->fireFeedbackChanged(); break;
        case 8: _t->fireApplicationStateChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 9: _t->fireScreenReaderRunningChanged(); break;
        case 10: _t->fireA11yFocusChanged((*reinterpret_cast<std::add_pointer_t<QQuickItem*>>(_a[1]))); break;
        case 11: _t->fireScreenRecordingChanged(); break;
        case 12: _t->fireScreenshotTaken(); break;
        case 13: _t->onApplicationStateChanged((*reinterpret_cast<std::add_pointer_t<Qt::ApplicationState>>(_a[1]))); break;
        case 14: _t->onWifiEnabledChanged(); break;
        case 15: _t->onTranslationChanged(); break;
        case 16: _t->onShowNextFeedback(); break;
        case 17: { int _r = _t->randomInt((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 18: _t->enableWifi(); break;
        case 19: _t->setClipboardText((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 20: _t->showSettings((*reinterpret_cast<std::add_pointer_t<enum Settings>>(_a[1]))); break;
        case 21: _t->showFeedback((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 22: _t->showFeedback((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 23: _t->keepScreenOn((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 24: _t->preventScreenshot((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 25: { QStringList _r = _t->getLicenseText();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 26: { QUrl _r = _t->getCustomConfigPath();
            if (_a[0]) *reinterpret_cast<QUrl*>(_a[0]) = std::move(_r); }  break;
        case 27: _t->saveEmbeddedConfig((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 28: { QString _r = _t->stripHtmlTags((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 29: _t->showAppStoreRatingDialog(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 10:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QQuickItem* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (ApplicationModel::*)()>(_a, &ApplicationModel::fireAppAboutToQuit, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (ApplicationModel::*)()>(_a, &ApplicationModel::fireStoreUrlChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (ApplicationModel::*)()>(_a, &ApplicationModel::fireNfcStateChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (ApplicationModel::*)()>(_a, &ApplicationModel::fireReaderPropertiesUpdated, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (ApplicationModel::*)()>(_a, &ApplicationModel::fireCurrentWorkflowChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (ApplicationModel::*)()>(_a, &ApplicationModel::fireAvailableReaderChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (ApplicationModel::*)()>(_a, &ApplicationModel::fireWifiEnabledChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (ApplicationModel::*)()>(_a, &ApplicationModel::fireFeedbackChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (ApplicationModel::*)(bool )>(_a, &ApplicationModel::fireApplicationStateChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (ApplicationModel::*)()>(_a, &ApplicationModel::fireScreenReaderRunningChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (ApplicationModel::*)(QQuickItem * )>(_a, &ApplicationModel::fireA11yFocusChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (ApplicationModel::*)()>(_a, &ApplicationModel::fireScreenRecordingChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (ApplicationModel::*)()>(_a, &ApplicationModel::fireScreenshotTaken, 12))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->getStoreUrl(); break;
        case 1: *reinterpret_cast<enum NfcState*>(_v) = _t->getNfcState(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->isExtendedLengthApdusUnsupported(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->isWifiEnabled(); break;
        case 4: *reinterpret_cast<enum Workflow*>(_v) = _t->getCurrentWorkflow(); break;
        case 5: *reinterpret_cast<qsizetype*>(_v) = _t->getAvailablePcscReader(); break;
        case 6: *reinterpret_cast<qsizetype*>(_v) = _t->getAvailableRemoteReader(); break;
        case 7: *reinterpret_cast<governikus::EnumReaderManagerPluginType::ReaderManagerPluginType*>(_v) = _t->getUsedPluginType(); break;
        case 8: *reinterpret_cast<QString*>(_v) = _t->getFeedback(); break;
        case 9: *reinterpret_cast<int*>(_v) = _t->getFeedbackTimeout(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->isScreenReaderRunning(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->isScreenRecording(); break;
        case 12: *reinterpret_cast<QUrl*>(_v) = _t->getCustomConfigPath(); break;
        default: break;
        }
    }
}

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

void *governikus::ApplicationModel::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10governikus16ApplicationModelE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "SingletonCreator<ApplicationModel>"))
        return static_cast< SingletonCreator<ApplicationModel>*>(this);
    return QObject::qt_metacast(_clname);
}

int governikus::ApplicationModel::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 < 30)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 30;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 30)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 30;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 13;
    }
    return _id;
}

// SIGNAL 0
void governikus::ApplicationModel::fireAppAboutToQuit()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void governikus::ApplicationModel::fireStoreUrlChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void governikus::ApplicationModel::fireNfcStateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void governikus::ApplicationModel::fireReaderPropertiesUpdated()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void governikus::ApplicationModel::fireCurrentWorkflowChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void governikus::ApplicationModel::fireAvailableReaderChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void governikus::ApplicationModel::fireWifiEnabledChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void governikus::ApplicationModel::fireFeedbackChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void governikus::ApplicationModel::fireApplicationStateChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void governikus::ApplicationModel::fireScreenReaderRunningChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void governikus::ApplicationModel::fireA11yFocusChanged(QQuickItem * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void governikus::ApplicationModel::fireScreenRecordingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void governikus::ApplicationModel::fireScreenshotTaken()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}
QT_WARNING_POP
