/****************************************************************************
** Meta object code from reading C++ file 'notifications.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 "../../../../plasma-workspace-6.7.1/libnotificationmanager/notifications.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 'notifications.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_ZN19NotificationManager13NotificationsE_t {};
} // unnamed namespace

template <> constexpr inline auto NotificationManager::Notifications::qt_create_metaobjectdata<qt_meta_tag_ZN19NotificationManager13NotificationsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "NotificationManager::Notifications",
        "QML.Element",
        "auto",
        "limitChanged",
        "",
        "showExpiredChanged",
        "showDismissedChanged",
        "showAddedDuringInhibitionChanged",
        "ignoreBlacklistDuringInhibitionChanged",
        "blacklistedDesktopEntriesChanged",
        "blacklistedNotifyRcNamesChanged",
        "whitelistedDesktopEntriesChanged",
        "whitelistedNotifyRcNamesChanged",
        "showNotificationsChanged",
        "showJobsChanged",
        "urgenciesChanged",
        "sortModeChanged",
        "sortOrderChanged",
        "groupModeChanged",
        "groupLimitChanged",
        "expandUnreadChanged",
        "countChanged",
        "activeNotificationsCountChanged",
        "expiredNotificationsCountChanged",
        "lastReadChanged",
        "unreadNotificationsCountChanged",
        "dismissedResidentNotificationsCountChanged",
        "activeJobsCountChanged",
        "jobsPercentageChanged",
        "windowChanged",
        "QWindow*",
        "window",
        "showNotificationsRequested",
        "makePersistentModelIndex",
        "QPersistentModelIndex",
        "QModelIndex",
        "idx",
        "expire",
        "close",
        "configure",
        "invokeDefaultAction",
        "InvokeBehavior",
        "behavior",
        "invokeAction",
        "actionId",
        "reply",
        "text",
        "startTimeout",
        "notificationId",
        "stopTimeout",
        "suspendJob",
        "resumeJob",
        "killJob",
        "clear",
        "ClearFlags",
        "flags",
        "groupIndex",
        "collapseAllGroups",
        "playSoundHint",
        "showInhibitionSummary",
        "Urgency",
        "urgency",
        "blacklistedDesktopEntries",
        "blacklistedNotifyRcNames",
        "hideInhibitionSummary",
        "limit",
        "showExpired",
        "showDismissed",
        "showAddedDuringInhibition",
        "ignoreBlacklistDuringInhibition",
        "whitelistedDesktopEntries",
        "whitelistedNotifyRcNames",
        "showNotifications",
        "showJobs",
        "urgencies",
        "Urgencies",
        "sortMode",
        "SortMode",
        "sortOrder",
        "Qt::SortOrder",
        "groupMode",
        "GroupMode",
        "groupLimit",
        "expandUnread",
        "count",
        "activeNotificationsCount",
        "expiredNotificationsCount",
        "lastRead",
        "unreadNotificationsCount",
        "dismissedResidentNotificationsCount",
        "activeJobsCount",
        "jobsPercentage",
        "Roles",
        "IdRole",
        "SummaryRole",
        "ImageRole",
        "IsGroupRole",
        "GroupChildrenCountRole",
        "ExpandedGroupChildrenCountRole",
        "IsGroupExpandedRole",
        "IsInGroupRole",
        "TypeRole",
        "CreatedRole",
        "UpdatedRole",
        "BodyRole",
        "IconNameRole",
        "DesktopEntryRole",
        "NotifyRcNameRole",
        "ApplicationNameRole",
        "ApplicationIconNameRole",
        "OriginNameRole",
        "JobStateRole",
        "PercentageRole",
        "JobErrorRole",
        "SuspendableRole",
        "KillableRole",
        "JobDetailsRole",
        "ActionNamesRole",
        "ActionLabelsRole",
        "HasDefaultActionRole",
        "DefaultActionLabelRole",
        "UrlsRole",
        "UrgencyRole",
        "TimeoutRole",
        "ConfigurableRole",
        "ConfigureActionLabelRole",
        "ClosableRole",
        "ExpiredRole",
        "DismissedRole",
        "ReadRole",
        "UserActionFeedbackRole",
        "HasReplyActionRole",
        "ReplyActionLabelRole",
        "ReplyPlaceholderTextRole",
        "ReplySubmitButtonTextRole",
        "ReplySubmitButtonIconNameRole",
        "CategoryRole",
        "ResidentRole",
        "TransientRole",
        "WasAddedDuringInhibitionRole",
        "HintsRole",
        "DismissableRole",
        "Type",
        "NoType",
        "NotificationType",
        "JobType",
        "LowUrgency",
        "NormalUrgency",
        "CriticalUrgency",
        "ClearFlag",
        "ClearExpired",
        "JobState",
        "JobStateStopped",
        "JobStateRunning",
        "JobStateSuspended",
        "SortByDate",
        "SortByTypeAndUrgency",
        "GroupDisabled",
        "GroupApplicationsFlat",
        "None",
        "Close",
        "InvokeBehaviors"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'limitChanged'
        QtMocHelpers::SignalData<void()>(3, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showExpiredChanged'
        QtMocHelpers::SignalData<void()>(5, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showDismissedChanged'
        QtMocHelpers::SignalData<void()>(6, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showAddedDuringInhibitionChanged'
        QtMocHelpers::SignalData<void()>(7, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'ignoreBlacklistDuringInhibitionChanged'
        QtMocHelpers::SignalData<void()>(8, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'blacklistedDesktopEntriesChanged'
        QtMocHelpers::SignalData<void()>(9, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'blacklistedNotifyRcNamesChanged'
        QtMocHelpers::SignalData<void()>(10, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'whitelistedDesktopEntriesChanged'
        QtMocHelpers::SignalData<void()>(11, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'whitelistedNotifyRcNamesChanged'
        QtMocHelpers::SignalData<void()>(12, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showNotificationsChanged'
        QtMocHelpers::SignalData<void()>(13, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showJobsChanged'
        QtMocHelpers::SignalData<void()>(14, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'urgenciesChanged'
        QtMocHelpers::SignalData<void()>(15, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sortModeChanged'
        QtMocHelpers::SignalData<void()>(16, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sortOrderChanged'
        QtMocHelpers::SignalData<void()>(17, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'groupModeChanged'
        QtMocHelpers::SignalData<void()>(18, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'groupLimitChanged'
        QtMocHelpers::SignalData<void()>(19, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'expandUnreadChanged'
        QtMocHelpers::SignalData<void()>(20, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'countChanged'
        QtMocHelpers::SignalData<void()>(21, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'activeNotificationsCountChanged'
        QtMocHelpers::SignalData<void()>(22, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'expiredNotificationsCountChanged'
        QtMocHelpers::SignalData<void()>(23, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lastReadChanged'
        QtMocHelpers::SignalData<void()>(24, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'unreadNotificationsCountChanged'
        QtMocHelpers::SignalData<void()>(25, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'dismissedResidentNotificationsCountChanged'
        QtMocHelpers::SignalData<void()>(26, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'activeJobsCountChanged'
        QtMocHelpers::SignalData<void()>(27, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'jobsPercentageChanged'
        QtMocHelpers::SignalData<void()>(28, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'windowChanged'
        QtMocHelpers::SignalData<void(QWindow *)>(29, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 30, 31 },
        }}),
        // Signal 'showNotificationsRequested'
        QtMocHelpers::SignalData<void()>(32, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'makePersistentModelIndex'
        QtMocHelpers::MethodData<QPersistentModelIndex(const QModelIndex &) const>(33, 4, QMC::AccessPublic, 0x80000000 | 34, {{
            { 0x80000000 | 35, 36 },
        }}),
        // Method 'expire'
        QtMocHelpers::MethodData<void(const QModelIndex &)>(37, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 36 },
        }}),
        // Method 'close'
        QtMocHelpers::MethodData<void(const QModelIndex &)>(38, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 36 },
        }}),
        // Method 'configure'
        QtMocHelpers::MethodData<void(const QModelIndex &)>(39, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 36 },
        }}),
        // Method 'invokeDefaultAction'
        QtMocHelpers::MethodData<void(const QModelIndex &, enum InvokeBehavior)>(40, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 36 }, { 0x80000000 | 41, 42 },
        }}),
        // Method 'invokeDefaultAction'
        QtMocHelpers::MethodData<void(const QModelIndex &)>(40, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 35, 36 },
        }}),
        // Method 'invokeAction'
        QtMocHelpers::MethodData<void(const QModelIndex &, const QString &, enum InvokeBehavior)>(43, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 36 }, { QMetaType::QString, 44 }, { 0x80000000 | 41, 4 },
        }}),
        // Method 'invokeAction'
        QtMocHelpers::MethodData<void(const QModelIndex &, const QString &)>(43, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 35, 36 }, { QMetaType::QString, 44 },
        }}),
        // Method 'reply'
        QtMocHelpers::MethodData<void(const QModelIndex &, const QString &, enum InvokeBehavior)>(45, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 36 }, { QMetaType::QString, 46 }, { 0x80000000 | 41, 42 },
        }}),
        // Method 'startTimeout'
        QtMocHelpers::MethodData<void(const QModelIndex &)>(47, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 36 },
        }}),
        // Method 'startTimeout'
        QtMocHelpers::MethodData<void(uint)>(47, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::UInt, 48 },
        }}),
        // Method 'stopTimeout'
        QtMocHelpers::MethodData<void(const QModelIndex &)>(49, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 36 },
        }}),
        // Method 'suspendJob'
        QtMocHelpers::MethodData<void(const QModelIndex &)>(50, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 36 },
        }}),
        // Method 'resumeJob'
        QtMocHelpers::MethodData<void(const QModelIndex &)>(51, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 36 },
        }}),
        // Method 'killJob'
        QtMocHelpers::MethodData<void(const QModelIndex &)>(52, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 36 },
        }}),
        // Method 'clear'
        QtMocHelpers::MethodData<void(ClearFlags)>(53, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 54, 55 },
        }}),
        // Method 'groupIndex'
        QtMocHelpers::MethodData<QModelIndex(const QModelIndex &) const>(56, 4, QMC::AccessPublic, 0x80000000 | 35, {{
            { 0x80000000 | 35, 36 },
        }}),
        // Method 'collapseAllGroups'
        QtMocHelpers::MethodData<void()>(57, 4, QMC::AccessPublic, QMetaType::Void),
        // Method 'playSoundHint'
        QtMocHelpers::MethodData<void(const QModelIndex &) const>(58, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 35, 36 },
        }}),
        // Method 'showInhibitionSummary'
        QtMocHelpers::MethodData<void(enum Urgency, const QStringList &, const QStringList &)>(59, 4, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 60, 61 }, { QMetaType::QStringList, 62 }, { QMetaType::QStringList, 63 },
        }}),
        // Method 'hideInhibitionSummary'
        QtMocHelpers::MethodData<void()>(64, 4, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'limit'
        QtMocHelpers::PropertyData<int>(65, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
        // property 'showExpired'
        QtMocHelpers::PropertyData<bool>(66, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'showDismissed'
        QtMocHelpers::PropertyData<bool>(67, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'showAddedDuringInhibition'
        QtMocHelpers::PropertyData<bool>(68, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'ignoreBlacklistDuringInhibition'
        QtMocHelpers::PropertyData<bool>(69, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'blacklistedDesktopEntries'
        QtMocHelpers::PropertyData<QStringList>(62, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'blacklistedNotifyRcNames'
        QtMocHelpers::PropertyData<QStringList>(63, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 6),
        // property 'whitelistedDesktopEntries'
        QtMocHelpers::PropertyData<QStringList>(70, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 7),
        // property 'whitelistedNotifyRcNames'
        QtMocHelpers::PropertyData<QStringList>(71, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'showNotifications'
        QtMocHelpers::PropertyData<bool>(72, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'showJobs'
        QtMocHelpers::PropertyData<bool>(73, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'urgencies'
        QtMocHelpers::PropertyData<Urgencies>(74, 0x80000000 | 75, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 11),
        // property 'sortMode'
        QtMocHelpers::PropertyData<enum SortMode>(76, 0x80000000 | 77, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 12),
        // property 'sortOrder'
        QtMocHelpers::PropertyData<Qt::SortOrder>(78, 0x80000000 | 79, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 13),
        // property 'groupMode'
        QtMocHelpers::PropertyData<enum GroupMode>(80, 0x80000000 | 81, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 14),
        // property 'groupLimit'
        QtMocHelpers::PropertyData<int>(82, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'expandUnread'
        QtMocHelpers::PropertyData<bool>(83, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'count'
        QtMocHelpers::PropertyData<int>(84, QMetaType::Int, QMC::DefaultPropertyFlags, 17),
        // property 'activeNotificationsCount'
        QtMocHelpers::PropertyData<int>(85, QMetaType::Int, QMC::DefaultPropertyFlags, 18),
        // property 'expiredNotificationsCount'
        QtMocHelpers::PropertyData<int>(86, QMetaType::Int, QMC::DefaultPropertyFlags, 19),
        // property 'lastRead'
        QtMocHelpers::PropertyData<QDateTime>(87, QMetaType::QDateTime, QMC::DefaultPropertyFlags | QMC::Writable | QMC::Resettable | QMC::StdCppSet, 20),
        // property 'unreadNotificationsCount'
        QtMocHelpers::PropertyData<int>(88, QMetaType::Int, QMC::DefaultPropertyFlags, 21),
        // property 'dismissedResidentNotificationsCount'
        QtMocHelpers::PropertyData<int>(89, QMetaType::Int, QMC::DefaultPropertyFlags, 22),
        // property 'activeJobsCount'
        QtMocHelpers::PropertyData<int>(90, QMetaType::Int, QMC::DefaultPropertyFlags, 23),
        // property 'jobsPercentage'
        QtMocHelpers::PropertyData<int>(91, QMetaType::Int, QMC::DefaultPropertyFlags, 24),
        // property 'window'
        QtMocHelpers::PropertyData<QWindow*>(31, 0x80000000 | 30, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 25),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Roles'
        QtMocHelpers::EnumData<enum Roles>(92, 92, QMC::EnumFlags{}).add({
            {   93, Roles::IdRole },
            {   94, Roles::SummaryRole },
            {   95, Roles::ImageRole },
            {   96, Roles::IsGroupRole },
            {   97, Roles::GroupChildrenCountRole },
            {   98, Roles::ExpandedGroupChildrenCountRole },
            {   99, Roles::IsGroupExpandedRole },
            {  100, Roles::IsInGroupRole },
            {  101, Roles::TypeRole },
            {  102, Roles::CreatedRole },
            {  103, Roles::UpdatedRole },
            {  104, Roles::BodyRole },
            {  105, Roles::IconNameRole },
            {  106, Roles::DesktopEntryRole },
            {  107, Roles::NotifyRcNameRole },
            {  108, Roles::ApplicationNameRole },
            {  109, Roles::ApplicationIconNameRole },
            {  110, Roles::OriginNameRole },
            {  111, Roles::JobStateRole },
            {  112, Roles::PercentageRole },
            {  113, Roles::JobErrorRole },
            {  114, Roles::SuspendableRole },
            {  115, Roles::KillableRole },
            {  116, Roles::JobDetailsRole },
            {  117, Roles::ActionNamesRole },
            {  118, Roles::ActionLabelsRole },
            {  119, Roles::HasDefaultActionRole },
            {  120, Roles::DefaultActionLabelRole },
            {  121, Roles::UrlsRole },
            {  122, Roles::UrgencyRole },
            {  123, Roles::TimeoutRole },
            {  124, Roles::ConfigurableRole },
            {  125, Roles::ConfigureActionLabelRole },
            {  126, Roles::ClosableRole },
            {  127, Roles::ExpiredRole },
            {  128, Roles::DismissedRole },
            {  129, Roles::ReadRole },
            {  130, Roles::UserActionFeedbackRole },
            {  131, Roles::HasReplyActionRole },
            {  132, Roles::ReplyActionLabelRole },
            {  133, Roles::ReplyPlaceholderTextRole },
            {  134, Roles::ReplySubmitButtonTextRole },
            {  135, Roles::ReplySubmitButtonIconNameRole },
            {  136, Roles::CategoryRole },
            {  137, Roles::ResidentRole },
            {  138, Roles::TransientRole },
            {  139, Roles::WasAddedDuringInhibitionRole },
            {  140, Roles::HintsRole },
            {  141, Roles::DismissableRole },
        }),
        // enum 'Type'
        QtMocHelpers::EnumData<enum Type>(142, 142, QMC::EnumFlags{}).add({
            {  143, Type::NoType },
            {  144, Type::NotificationType },
            {  145, Type::JobType },
        }),
        // enum 'Urgency'
        QtMocHelpers::EnumData<enum Urgency>(60, 60, QMC::EnumFlags{}).add({
            {  146, Urgency::LowUrgency },
            {  147, Urgency::NormalUrgency },
            {  148, Urgency::CriticalUrgency },
        }),
        // flag 'Urgencies'
        QtMocHelpers::EnumData<Urgencies>(75, 60, QMC::EnumIsFlag).add({
            {  146, Urgency::LowUrgency },
            {  147, Urgency::NormalUrgency },
            {  148, Urgency::CriticalUrgency },
        }),
        // enum 'ClearFlag'
        QtMocHelpers::EnumData<enum ClearFlag>(149, 149, QMC::EnumFlags{}).add({
            {  150, ClearFlag::ClearExpired },
        }),
        // flag 'ClearFlags'
        QtMocHelpers::EnumData<ClearFlags>(54, 149, QMC::EnumIsFlag).add({
            {  150, ClearFlag::ClearExpired },
        }),
        // enum 'JobState'
        QtMocHelpers::EnumData<enum JobState>(151, 151, QMC::EnumFlags{}).add({
            {  152, JobState::JobStateStopped },
            {  153, JobState::JobStateRunning },
            {  154, JobState::JobStateSuspended },
        }),
        // enum 'SortMode'
        QtMocHelpers::EnumData<enum SortMode>(77, 77, QMC::EnumFlags{}).add({
            {  155, SortMode::SortByDate },
            {  156, SortMode::SortByTypeAndUrgency },
        }),
        // enum 'GroupMode'
        QtMocHelpers::EnumData<enum GroupMode>(81, 81, QMC::EnumFlags{}).add({
            {  157, GroupMode::GroupDisabled },
            {  158, GroupMode::GroupApplicationsFlat },
        }),
        // enum 'InvokeBehavior'
        QtMocHelpers::EnumData<enum InvokeBehavior>(41, 41, QMC::EnumFlags{}).add({
            {  159, InvokeBehavior::None },
            {  160, InvokeBehavior::Close },
        }),
        // flag 'InvokeBehaviors'
        QtMocHelpers::EnumData<InvokeBehaviors>(161, 41, QMC::EnumIsFlag).add({
            {  159, InvokeBehavior::None },
            {  160, InvokeBehavior::Close },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<Notifications, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject NotificationManager::Notifications::staticMetaObject = { {
    QMetaObject::SuperData::link<QSortFilterProxyModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19NotificationManager13NotificationsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19NotificationManager13NotificationsE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN19NotificationManager13NotificationsE_t>.metaTypes,
    nullptr
} };

void NotificationManager::Notifications::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Notifications *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->limitChanged(); break;
        case 1: _t->showExpiredChanged(); break;
        case 2: _t->showDismissedChanged(); break;
        case 3: _t->showAddedDuringInhibitionChanged(); break;
        case 4: _t->ignoreBlacklistDuringInhibitionChanged(); break;
        case 5: _t->blacklistedDesktopEntriesChanged(); break;
        case 6: _t->blacklistedNotifyRcNamesChanged(); break;
        case 7: _t->whitelistedDesktopEntriesChanged(); break;
        case 8: _t->whitelistedNotifyRcNamesChanged(); break;
        case 9: _t->showNotificationsChanged(); break;
        case 10: _t->showJobsChanged(); break;
        case 11: _t->urgenciesChanged(); break;
        case 12: _t->sortModeChanged(); break;
        case 13: _t->sortOrderChanged(); break;
        case 14: _t->groupModeChanged(); break;
        case 15: _t->groupLimitChanged(); break;
        case 16: _t->expandUnreadChanged(); break;
        case 17: _t->countChanged(); break;
        case 18: _t->activeNotificationsCountChanged(); break;
        case 19: _t->expiredNotificationsCountChanged(); break;
        case 20: _t->lastReadChanged(); break;
        case 21: _t->unreadNotificationsCountChanged(); break;
        case 22: _t->dismissedResidentNotificationsCountChanged(); break;
        case 23: _t->activeJobsCountChanged(); break;
        case 24: _t->jobsPercentageChanged(); break;
        case 25: _t->windowChanged((*reinterpret_cast<std::add_pointer_t<QWindow*>>(_a[1]))); break;
        case 26: _t->showNotificationsRequested(); break;
        case 27: { QPersistentModelIndex _r = _t->makePersistentModelIndex((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QPersistentModelIndex*>(_a[0]) = std::move(_r); }  break;
        case 28: _t->expire((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 29: _t->close((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 30: _t->configure((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 31: _t->invokeDefaultAction((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<enum InvokeBehavior>>(_a[2]))); break;
        case 32: _t->invokeDefaultAction((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 33: _t->invokeAction((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<enum InvokeBehavior>>(_a[3]))); break;
        case 34: _t->invokeAction((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 35: _t->reply((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<enum InvokeBehavior>>(_a[3]))); break;
        case 36: _t->startTimeout((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 37: _t->startTimeout((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 38: _t->stopTimeout((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 39: _t->suspendJob((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 40: _t->resumeJob((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 41: _t->killJob((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 42: _t->clear((*reinterpret_cast<std::add_pointer_t<ClearFlags>>(_a[1]))); break;
        case 43: { QModelIndex _r = _t->groupIndex((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QModelIndex*>(_a[0]) = std::move(_r); }  break;
        case 44: _t->collapseAllGroups(); break;
        case 45: _t->playSoundHint((*reinterpret_cast<std::add_pointer_t<QModelIndex>>(_a[1]))); break;
        case 46: _t->showInhibitionSummary((*reinterpret_cast<std::add_pointer_t<enum Urgency>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[3]))); break;
        case 47: _t->hideInhibitionSummary(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 25:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QWindow* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::limitChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::showExpiredChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::showDismissedChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::showAddedDuringInhibitionChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::ignoreBlacklistDuringInhibitionChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::blacklistedDesktopEntriesChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::blacklistedNotifyRcNamesChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::whitelistedDesktopEntriesChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::whitelistedNotifyRcNamesChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::showNotificationsChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::showJobsChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::urgenciesChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::sortModeChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::sortOrderChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::groupModeChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::groupLimitChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::expandUnreadChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::countChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::activeNotificationsCountChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::expiredNotificationsCountChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::lastReadChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::unreadNotificationsCountChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::dismissedResidentNotificationsCountChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::activeJobsCountChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::jobsPercentageChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)(QWindow * )>(_a, &Notifications::windowChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (Notifications::*)()>(_a, &Notifications::showNotificationsRequested, 26))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 25:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< QWindow* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->limit(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->showExpired(); break;
        case 2: *reinterpret_cast<bool*>(_v) = _t->showDismissed(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->showAddedDuringInhibition(); break;
        case 4: *reinterpret_cast<bool*>(_v) = _t->ignoreBlacklistDuringInhibition(); break;
        case 5: *reinterpret_cast<QStringList*>(_v) = _t->blacklistedDesktopEntries(); break;
        case 6: *reinterpret_cast<QStringList*>(_v) = _t->blacklistedNotifyRcNames(); break;
        case 7: *reinterpret_cast<QStringList*>(_v) = _t->whitelistedDesktopEntries(); break;
        case 8: *reinterpret_cast<QStringList*>(_v) = _t->whitelistedNotifyRcNames(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->showNotifications(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->showJobs(); break;
        case 11: QtMocHelpers::assignFlags<Urgencies>(_v, _t->urgencies()); break;
        case 12: *reinterpret_cast<enum SortMode*>(_v) = _t->sortMode(); break;
        case 13: *reinterpret_cast<Qt::SortOrder*>(_v) = _t->sortOrder(); break;
        case 14: *reinterpret_cast<enum GroupMode*>(_v) = _t->groupMode(); break;
        case 15: *reinterpret_cast<int*>(_v) = _t->groupLimit(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->expandUnread(); break;
        case 17: *reinterpret_cast<int*>(_v) = _t->count(); break;
        case 18: *reinterpret_cast<int*>(_v) = _t->activeNotificationsCount(); break;
        case 19: *reinterpret_cast<int*>(_v) = _t->expiredNotificationsCount(); break;
        case 20: *reinterpret_cast<QDateTime*>(_v) = _t->lastRead(); break;
        case 21: *reinterpret_cast<int*>(_v) = _t->unreadNotificationsCount(); break;
        case 22: *reinterpret_cast<int*>(_v) = _t->dismissedResidentNotificationsCount(); break;
        case 23: *reinterpret_cast<int*>(_v) = _t->activeJobsCount(); break;
        case 24: *reinterpret_cast<int*>(_v) = _t->jobsPercentage(); break;
        case 25: *reinterpret_cast<QWindow**>(_v) = _t->window(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setLimit(*reinterpret_cast<int*>(_v)); break;
        case 1: _t->setShowExpired(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->setShowDismissed(*reinterpret_cast<bool*>(_v)); break;
        case 3: _t->setShowAddedDuringInhibition(*reinterpret_cast<bool*>(_v)); break;
        case 4: _t->setIgnoreBlacklistDuringInhibition(*reinterpret_cast<bool*>(_v)); break;
        case 5: _t->setBlacklistedDesktopEntries(*reinterpret_cast<QStringList*>(_v)); break;
        case 6: _t->setBlacklistedNotifyRcNames(*reinterpret_cast<QStringList*>(_v)); break;
        case 7: _t->setWhitelistedDesktopEntries(*reinterpret_cast<QStringList*>(_v)); break;
        case 8: _t->setWhitelistedNotifyRcNames(*reinterpret_cast<QStringList*>(_v)); break;
        case 9: _t->setShowNotifications(*reinterpret_cast<bool*>(_v)); break;
        case 10: _t->setShowJobs(*reinterpret_cast<bool*>(_v)); break;
        case 11: _t->setUrgencies(*reinterpret_cast<Urgencies*>(_v)); break;
        case 12: _t->setSortMode(*reinterpret_cast<enum SortMode*>(_v)); break;
        case 13: _t->setSortOrder(*reinterpret_cast<Qt::SortOrder*>(_v)); break;
        case 14: _t->setGroupMode(*reinterpret_cast<enum GroupMode*>(_v)); break;
        case 15: _t->setGroupLimit(*reinterpret_cast<int*>(_v)); break;
        case 16: _t->setExpandUnread(*reinterpret_cast<bool*>(_v)); break;
        case 20: _t->setLastRead(*reinterpret_cast<QDateTime*>(_v)); break;
        case 25: _t->setWindow(*reinterpret_cast<QWindow**>(_v)); break;
        default: break;
        }
    }
    if (_c == QMetaObject::ResetProperty) {
        switch (_id) {
        case 20: _t->resetLastRead(); break;
        default: break;
        }
    }
}

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

void *NotificationManager::Notifications::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN19NotificationManager13NotificationsE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "QQmlParserStatus"))
        return static_cast< QQmlParserStatus*>(this);
    if (!strcmp(_clname, "org.qt-project.Qt.QQmlParserStatus"))
        return static_cast< QQmlParserStatus*>(this);
    return QSortFilterProxyModel::qt_metacast(_clname);
}

int NotificationManager::Notifications::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = QSortFilterProxyModel::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 48)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 48;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 48)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 48;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 26;
    }
    return _id;
}

// SIGNAL 0
void NotificationManager::Notifications::limitChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void NotificationManager::Notifications::showExpiredChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void NotificationManager::Notifications::showDismissedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void NotificationManager::Notifications::showAddedDuringInhibitionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void NotificationManager::Notifications::ignoreBlacklistDuringInhibitionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void NotificationManager::Notifications::blacklistedDesktopEntriesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void NotificationManager::Notifications::blacklistedNotifyRcNamesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void NotificationManager::Notifications::whitelistedDesktopEntriesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void NotificationManager::Notifications::whitelistedNotifyRcNamesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void NotificationManager::Notifications::showNotificationsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void NotificationManager::Notifications::showJobsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void NotificationManager::Notifications::urgenciesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void NotificationManager::Notifications::sortModeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}

// SIGNAL 13
void NotificationManager::Notifications::sortOrderChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void NotificationManager::Notifications::groupModeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void NotificationManager::Notifications::groupLimitChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void NotificationManager::Notifications::expandUnreadChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void NotificationManager::Notifications::countChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void NotificationManager::Notifications::activeNotificationsCountChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 18, nullptr);
}

// SIGNAL 19
void NotificationManager::Notifications::expiredNotificationsCountChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 19, nullptr);
}

// SIGNAL 20
void NotificationManager::Notifications::lastReadChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 20, nullptr);
}

// SIGNAL 21
void NotificationManager::Notifications::unreadNotificationsCountChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 21, nullptr);
}

// SIGNAL 22
void NotificationManager::Notifications::dismissedResidentNotificationsCountChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}

// SIGNAL 23
void NotificationManager::Notifications::activeJobsCountChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 23, nullptr);
}

// SIGNAL 24
void NotificationManager::Notifications::jobsPercentageChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 24, nullptr);
}

// SIGNAL 25
void NotificationManager::Notifications::windowChanged(QWindow * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void NotificationManager::Notifications::showNotificationsRequested()
{
    QMetaObject::activate(this, &staticMetaObject, 26, nullptr);
}
QT_WARNING_POP
