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

#include "../../../nheko/src/timeline/TimelineModel.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 'TimelineModel.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.10.2. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto TimelineModel::qt_create_metaobjectdata<qt_meta_tag_ZN13TimelineModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "TimelineModel",
        "QML.Element",
        "Room",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "dataAtIdChanged",
        "id",
        "currentIndexChanged",
        "index",
        "redactionFailed",
        "mediaCached",
        "mxcUrl",
        "cacheUrl",
        "newEncryptedImage",
        "mtx::crypto::EncryptedFile",
        "encryptionInfo",
        "typingUsersChanged",
        "users",
        "replyChanged",
        "reply",
        "editChanged",
        "threadChanged",
        "openReadReceiptsDialog",
        "ReadReceiptsProxy*",
        "rr",
        "showRawMessageDialog",
        "rawMessage",
        "paginationInProgressChanged",
        "newCallEvent",
        "mtx::events::collections::TimelineEvents",
        "event",
        "scrollToIndex",
        "confetti",
        "confettiDone",
        "rainfall",
        "rainfallDone",
        "lastMessageChanged",
        "notificationsChanged",
        "newState",
        "mtx::responses::StateEvents",
        "events",
        "newMessageToSend",
        "addPendingMessageToStore",
        "updateFlowEventId",
        "std::string",
        "event_id",
        "parentSpaceChanged",
        "encryptionChanged",
        "fullyReadEventIdChanged",
        "trustlevelChanged",
        "roomNameChanged",
        "roomTopicChanged",
        "pinnedMessagesChanged",
        "widgetLinksChanged",
        "roomAvatarUrlChanged",
        "roomMemberCountChanged",
        "isDirectChanged",
        "directChatOtherUserIdChanged",
        "permissionsChanged",
        "forwardToRoom",
        "const mtx::events::collections::TimelineEvents*",
        "e",
        "roomId",
        "scrollTargetChanged",
        "fetchedMore",
        "setCurrentIndex",
        "ignoreInactiveState",
        "currentIndex",
        "eventShown",
        "markEventsAsRead",
        "std::vector<QString>",
        "event_ids",
        "markRoomAsRead",
        "updateLastReadId",
        "currentRoomId",
        "lastReadIdOnWindowFocus",
        "checkAfterFetch",
        "getDump",
        "QVariantMap",
        "eventId",
        "relatedTo",
        "updateTypingUsers",
        "typingUsers",
        "paginationInProgress",
        "setReply",
        "newReply",
        "resetReply",
        "edit",
        "setEdit",
        "newEdit",
        "resetEdit",
        "thread",
        "setThread",
        "newThread",
        "resetThread",
        "setDecryptDescription",
        "decrypt",
        "clearTimeline",
        "resetState",
        "receivedSessionKey",
        "session_key",
        "roomName",
        "plainRoomName",
        "roomTopic",
        "pinnedMessages",
        "widgetLinks",
        "input",
        "InputBar*",
        "permissions",
        "Permissions*",
        "roomAvatarUrl",
        "parentSpace",
        "RoomSummary*",
        "hasMentions",
        "notificationCount",
        "scrollTarget",
        "triggerSpecialEffects",
        "markSpecialEffectsDone",
        "addPendingMessage",
        "scrollTimerEvent",
        "dataById",
        "QVariant",
        "role",
        "dataByIndex",
        "i",
        "displayName",
        "avatarUrl",
        "formatDateSeparator",
        "date",
        "formatLaterSeparator",
        "prevDate",
        "formatTypingUsers",
        "QColor",
        "bg",
        "showAcceptKnockButton",
        "acceptKnock",
        "joinReplacementRoom",
        "formatMemberEvent",
        "mtx::events::StateEvent<mtx::events::state::Member>",
        "formatPolicyRule",
        "formatRedactedEvent",
        "showImage",
        "viewRawMessage",
        "forwardMessage",
        "viewDecryptedRawMessage",
        "openUserProfile",
        "userid",
        "unpin",
        "pin",
        "showReadReceipts",
        "redactEvent",
        "reason",
        "redactAllFromUser",
        "reportEvent",
        "score",
        "idToIndex",
        "indexToId",
        "openMedia",
        "cacheMedia",
        "saveMedia",
        "copyMedia",
        "showEvent",
        "copyLinkToEvent",
        "sendReset",
        "requestKeyForEvent",
        "roomMemberCount",
        "isEncrypted",
        "fullyReadEventId",
        "isSpace",
        "trustlevel",
        "isDirect",
        "directChatOtherUserId",
        "Roles",
        "Type",
        "TypeString",
        "IsOnlyEmoji",
        "Body",
        "FormattedBody",
        "FormattedStateEvent",
        "IsSender",
        "UserId",
        "UserName",
        "UserPowerlevel",
        "Day",
        "Timestamp",
        "Url",
        "ThumbnailUrl",
        "Duration",
        "Blurhash",
        "Filename",
        "Filesize",
        "MimeType",
        "OriginalHeight",
        "OriginalWidth",
        "ProportionalHeight",
        "EventId",
        "State",
        "IsEdited",
        "IsEditable",
        "IsEncrypted",
        "IsStateEvent",
        "Trustlevel",
        "Notificationlevel",
        "EncryptionError",
        "ReplyTo",
        "ThreadId",
        "Reactions",
        "RoomId",
        "RoomName",
        "RoomTopic",
        "CallType",
        "Dump",
        "RelatedEventCacheBuster"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'dataAtIdChanged'
        QtMocHelpers::SignalData<void(QString)>(7, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Signal 'currentIndexChanged'
        QtMocHelpers::SignalData<void(int)>(9, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 10 },
        }}),
        // Signal 'redactionFailed'
        QtMocHelpers::SignalData<void(QString)>(11, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Signal 'mediaCached'
        QtMocHelpers::SignalData<void(QString, QString)>(12, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 13 }, { QMetaType::QString, 14 },
        }}),
        // Signal 'newEncryptedImage'
        QtMocHelpers::SignalData<void(mtx::crypto::EncryptedFile)>(15, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 16, 17 },
        }}),
        // Signal 'typingUsersChanged'
        QtMocHelpers::SignalData<void(QStringList)>(18, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 19 },
        }}),
        // Signal 'replyChanged'
        QtMocHelpers::SignalData<void(QString)>(20, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 21 },
        }}),
        // Signal 'editChanged'
        QtMocHelpers::SignalData<void(QString)>(22, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 21 },
        }}),
        // Signal 'threadChanged'
        QtMocHelpers::SignalData<void(QString)>(23, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Signal 'openReadReceiptsDialog'
        QtMocHelpers::SignalData<void(ReadReceiptsProxy *)>(24, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 25, 26 },
        }}),
        // Signal 'showRawMessageDialog'
        QtMocHelpers::SignalData<void(QString)>(27, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 28 },
        }}),
        // Signal 'paginationInProgressChanged'
        QtMocHelpers::SignalData<void(const bool)>(29, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 6 },
        }}),
        // Signal 'newCallEvent'
        QtMocHelpers::SignalData<void(const mtx::events::collections::TimelineEvents &)>(30, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 31, 32 },
        }}),
        // Signal 'scrollToIndex'
        QtMocHelpers::SignalData<void(int)>(33, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 10 },
        }}),
        // Signal 'confetti'
        QtMocHelpers::SignalData<void()>(34, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'confettiDone'
        QtMocHelpers::SignalData<void()>(35, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'rainfall'
        QtMocHelpers::SignalData<void()>(36, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'rainfallDone'
        QtMocHelpers::SignalData<void()>(37, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lastMessageChanged'
        QtMocHelpers::SignalData<void()>(38, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'notificationsChanged'
        QtMocHelpers::SignalData<void()>(39, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'newState'
        QtMocHelpers::SignalData<void(const mtx::responses::StateEvents &)>(40, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 41, 42 },
        }}),
        // Signal 'newMessageToSend'
        QtMocHelpers::SignalData<void(mtx::events::collections::TimelineEvents)>(43, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 31, 32 },
        }}),
        // Signal 'addPendingMessageToStore'
        QtMocHelpers::SignalData<void(mtx::events::collections::TimelineEvents)>(44, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 31, 32 },
        }}),
        // Signal 'updateFlowEventId'
        QtMocHelpers::SignalData<void(std::string)>(45, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 46, 47 },
        }}),
        // Signal 'parentSpaceChanged'
        QtMocHelpers::SignalData<void()>(48, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'encryptionChanged'
        QtMocHelpers::SignalData<void()>(49, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fullyReadEventIdChanged'
        QtMocHelpers::SignalData<void()>(50, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'trustlevelChanged'
        QtMocHelpers::SignalData<void()>(51, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'roomNameChanged'
        QtMocHelpers::SignalData<void()>(52, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'roomTopicChanged'
        QtMocHelpers::SignalData<void()>(53, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'pinnedMessagesChanged'
        QtMocHelpers::SignalData<void()>(54, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'widgetLinksChanged'
        QtMocHelpers::SignalData<void()>(55, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'roomAvatarUrlChanged'
        QtMocHelpers::SignalData<void()>(56, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'roomMemberCountChanged'
        QtMocHelpers::SignalData<void()>(57, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'isDirectChanged'
        QtMocHelpers::SignalData<void()>(58, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'directChatOtherUserIdChanged'
        QtMocHelpers::SignalData<void()>(59, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'permissionsChanged'
        QtMocHelpers::SignalData<void()>(60, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'forwardToRoom'
        QtMocHelpers::SignalData<void(mtx::events::collections::TimelineEvents const *, QString)>(61, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 62, 63 }, { QMetaType::QString, 64 },
        }}),
        // Signal 'scrollTargetChanged'
        QtMocHelpers::SignalData<void()>(65, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fetchedMore'
        QtMocHelpers::SignalData<void()>(66, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setCurrentIndex'
        QtMocHelpers::SlotData<void(int)>(67, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 10 },
        }}),
        // Slot 'setCurrentIndex'
        QtMocHelpers::SlotData<void(int, bool)>(67, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 10 }, { QMetaType::Bool, 68 },
        }}),
        // Slot 'currentIndex'
        QtMocHelpers::SlotData<int() const>(69, 6, QMC::AccessPublic, QMetaType::Int),
        // Slot 'eventShown'
        QtMocHelpers::SlotData<void()>(70, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'markEventsAsRead'
        QtMocHelpers::SlotData<void(const std::vector<QString> &)>(71, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 72, 73 },
        }}),
        // Slot 'markRoomAsRead'
        QtMocHelpers::SlotData<void()>(74, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'updateLastReadId'
        QtMocHelpers::SlotData<void(const QString &)>(75, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 76 },
        }}),
        // Slot 'lastReadIdOnWindowFocus'
        QtMocHelpers::SlotData<void()>(77, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'checkAfterFetch'
        QtMocHelpers::SlotData<void()>(78, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'getDump'
        QtMocHelpers::SlotData<QVariantMap(const QString &, const QString &) const>(79, 6, QMC::AccessPublic, 0x80000000 | 80, {{
            { QMetaType::QString, 81 }, { QMetaType::QString, 82 },
        }}),
        // Slot 'updateTypingUsers'
        QtMocHelpers::SlotData<void(const QStringList &)>(83, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 19 },
        }}),
        // Slot 'typingUsers'
        QtMocHelpers::SlotData<QStringList() const>(84, 6, QMC::AccessPublic, QMetaType::QStringList),
        // Slot 'paginationInProgress'
        QtMocHelpers::SlotData<bool() const>(85, 6, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'reply'
        QtMocHelpers::SlotData<QString() const>(21, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setReply'
        QtMocHelpers::SlotData<void(const QString &)>(86, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 87 },
        }}),
        // Slot 'resetReply'
        QtMocHelpers::SlotData<void()>(88, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'edit'
        QtMocHelpers::SlotData<QString() const>(89, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setEdit'
        QtMocHelpers::SlotData<void(const QString &)>(90, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 91 },
        }}),
        // Slot 'resetEdit'
        QtMocHelpers::SlotData<void()>(92, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'thread'
        QtMocHelpers::SlotData<QString() const>(93, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setThread'
        QtMocHelpers::SlotData<void(const QString &)>(94, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 95 },
        }}),
        // Slot 'resetThread'
        QtMocHelpers::SlotData<void()>(96, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'setDecryptDescription'
        QtMocHelpers::SlotData<void(bool)>(97, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 98 },
        }}),
        // Slot 'clearTimeline'
        QtMocHelpers::SlotData<void()>(99, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'resetState'
        QtMocHelpers::SlotData<void()>(100, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'receivedSessionKey'
        QtMocHelpers::SlotData<void(const std::string &)>(101, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 46, 102 },
        }}),
        // Slot 'roomName'
        QtMocHelpers::SlotData<QString() const>(103, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'plainRoomName'
        QtMocHelpers::SlotData<QString() const>(104, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'roomTopic'
        QtMocHelpers::SlotData<QString() const>(105, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'pinnedMessages'
        QtMocHelpers::SlotData<QStringList() const>(106, 6, QMC::AccessPublic, QMetaType::QStringList),
        // Slot 'widgetLinks'
        QtMocHelpers::SlotData<QStringList() const>(107, 6, QMC::AccessPublic, QMetaType::QStringList),
        // Slot 'input'
        QtMocHelpers::SlotData<InputBar *()>(108, 6, QMC::AccessPublic, 0x80000000 | 109),
        // Slot 'permissions'
        QtMocHelpers::SlotData<Permissions *()>(110, 6, QMC::AccessPublic, 0x80000000 | 111),
        // Slot 'roomAvatarUrl'
        QtMocHelpers::SlotData<QString() const>(112, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'roomId'
        QtMocHelpers::SlotData<QString() const>(64, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'parentSpace'
        QtMocHelpers::SlotData<RoomSummary *()>(113, 6, QMC::AccessPublic, 0x80000000 | 114),
        // Slot 'hasMentions'
        QtMocHelpers::SlotData<bool() const>(115, 6, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'notificationCount'
        QtMocHelpers::SlotData<int() const>(116, 6, QMC::AccessPublic, QMetaType::Int),
        // Slot 'scrollTarget'
        QtMocHelpers::SlotData<QString() const>(117, 6, QMC::AccessPublic, QMetaType::QString),
        // Slot 'triggerSpecialEffects'
        QtMocHelpers::SlotData<void()>(118, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'markSpecialEffectsDone'
        QtMocHelpers::SlotData<void()>(119, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addPendingMessage'
        QtMocHelpers::SlotData<void(mtx::events::collections::TimelineEvents)>(120, 6, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 31, 32 },
        }}),
        // Slot 'scrollTimerEvent'
        QtMocHelpers::SlotData<void()>(121, 6, QMC::AccessPrivate, QMetaType::Void),
        // Method 'dataById'
        QtMocHelpers::MethodData<QVariant(const QString &, int, const QString &)>(122, 6, QMC::AccessPublic, 0x80000000 | 123, {{
            { QMetaType::QString, 8 }, { QMetaType::Int, 124 }, { QMetaType::QString, 82 },
        }}),
        // Method 'dataByIndex'
        QtMocHelpers::MethodData<QVariant(int, int) const>(125, 6, QMC::AccessPublic, 0x80000000 | 123, {{
            { QMetaType::Int, 126 }, { QMetaType::Int, 124 },
        }}),
        // Method 'dataByIndex'
        QtMocHelpers::MethodData<QVariant(int) const>(125, 6, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 123, {{
            { QMetaType::Int, 126 },
        }}),
        // Method 'displayName'
        QtMocHelpers::MethodData<QString(const QString &) const>(127, 6, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'avatarUrl'
        QtMocHelpers::MethodData<QString(const QString &) const>(128, 6, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'formatDateSeparator'
        QtMocHelpers::MethodData<QString(QDate) const>(129, 6, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QDate, 130 },
        }}),
        // Method 'formatLaterSeparator'
        QtMocHelpers::MethodData<QString(QDateTime, QDateTime) const>(131, 6, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QDateTime, 132 }, { QMetaType::QDateTime, 130 },
        }}),
        // Method 'formatTypingUsers'
        QtMocHelpers::MethodData<QString(const QStringList &, const QColor &)>(133, 6, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QStringList, 19 }, { 0x80000000 | 134, 135 },
        }}),
        // Method 'showAcceptKnockButton'
        QtMocHelpers::MethodData<bool(const QString &)>(136, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'acceptKnock'
        QtMocHelpers::MethodData<void(const QString &)>(137, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'joinReplacementRoom'
        QtMocHelpers::MethodData<void(const QString &)>(138, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'formatMemberEvent'
        QtMocHelpers::MethodData<QString(const mtx::events::StateEvent<mtx::events::state::Member> &) const>(139, 6, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 140, 32 },
        }}),
        // Method 'formatPolicyRule'
        QtMocHelpers::MethodData<QString(const QString &) const>(141, 6, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'formatRedactedEvent'
        QtMocHelpers::MethodData<QVariantMap(const QString &)>(142, 6, QMC::AccessPublic, 0x80000000 | 80, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'showImage'
        QtMocHelpers::MethodData<bool() const>(143, 6, QMC::AccessPublic, QMetaType::Bool),
        // Method 'viewRawMessage'
        QtMocHelpers::MethodData<void(const QString &)>(144, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'forwardMessage'
        QtMocHelpers::MethodData<void(const QString &, QString)>(145, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 81 }, { QMetaType::QString, 64 },
        }}),
        // Method 'viewDecryptedRawMessage'
        QtMocHelpers::MethodData<void(const QString &)>(146, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'openUserProfile'
        QtMocHelpers::MethodData<void(QString)>(147, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 148 },
        }}),
        // Method 'unpin'
        QtMocHelpers::MethodData<void(const QString &)>(149, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'pin'
        QtMocHelpers::MethodData<void(const QString &)>(150, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'showReadReceipts'
        QtMocHelpers::MethodData<void(const QString &)>(151, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'redactEvent'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(152, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 }, { QMetaType::QString, 153 },
        }}),
        // Method 'redactEvent'
        QtMocHelpers::MethodData<void(const QString &)>(152, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'redactAllFromUser'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(154, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 148 }, { QMetaType::QString, 153 },
        }}),
        // Method 'redactAllFromUser'
        QtMocHelpers::MethodData<void(const QString &)>(154, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 148 },
        }}),
        // Method 'reportEvent'
        QtMocHelpers::MethodData<void(const QString &, const QString &, const int)>(155, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 81 }, { QMetaType::QString, 153 }, { QMetaType::Int, 156 },
        }}),
        // Method 'reportEvent'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(155, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 81 }, { QMetaType::QString, 153 },
        }}),
        // Method 'reportEvent'
        QtMocHelpers::MethodData<void(const QString &)>(155, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 81 },
        }}),
        // Method 'idToIndex'
        QtMocHelpers::MethodData<int(const QString &) const>(157, 6, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::QString, 8 },
        }}),
        // Method 'indexToId'
        QtMocHelpers::MethodData<QString(int) const>(158, 6, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::Int, 10 },
        }}),
        // Method 'openMedia'
        QtMocHelpers::MethodData<void(const QString &)>(159, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 81 },
        }}),
        // Method 'cacheMedia'
        QtMocHelpers::MethodData<void(const QString &)>(160, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 81 },
        }}),
        // Method 'saveMedia'
        QtMocHelpers::MethodData<bool(const QString &) const>(161, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 81 },
        }}),
        // Method 'copyMedia'
        QtMocHelpers::MethodData<bool(const QString &) const>(162, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 81 },
        }}),
        // Method 'showEvent'
        QtMocHelpers::MethodData<void(QString)>(163, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 81 },
        }}),
        // Method 'copyLinkToEvent'
        QtMocHelpers::MethodData<void(const QString &) const>(164, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 81 },
        }}),
        // Method 'sendReset'
        QtMocHelpers::MethodData<void()>(165, 6, QMC::AccessPublic, QMetaType::Void),
        // Method 'requestKeyForEvent'
        QtMocHelpers::MethodData<void(const QString &)>(166, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 8 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'currentIndex'
        QtMocHelpers::PropertyData<int>(69, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'typingUsers'
        QtMocHelpers::PropertyData<QStringList>(84, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable, 5),
        // property 'scrollTarget'
        QtMocHelpers::PropertyData<QString>(117, QMetaType::QString, QMC::DefaultPropertyFlags, 38),
        // property 'reply'
        QtMocHelpers::PropertyData<QString>(21, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::Resettable | QMC::StdCppSet, 6),
        // property 'edit'
        QtMocHelpers::PropertyData<QString>(89, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::Resettable | QMC::StdCppSet, 7),
        // property 'thread'
        QtMocHelpers::PropertyData<QString>(93, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::Resettable | QMC::StdCppSet, 8),
        // property 'paginationInProgress'
        QtMocHelpers::PropertyData<bool>(85, QMetaType::Bool, QMC::DefaultPropertyFlags, 11),
        // property 'roomId'
        QtMocHelpers::PropertyData<QString>(64, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'roomName'
        QtMocHelpers::PropertyData<QString>(103, QMetaType::QString, QMC::DefaultPropertyFlags, 28),
        // property 'plainRoomName'
        QtMocHelpers::PropertyData<QString>(104, QMetaType::QString, QMC::DefaultPropertyFlags, 28),
        // property 'roomAvatarUrl'
        QtMocHelpers::PropertyData<QString>(112, QMetaType::QString, QMC::DefaultPropertyFlags, 32),
        // property 'roomTopic'
        QtMocHelpers::PropertyData<QString>(105, QMetaType::QString, QMC::DefaultPropertyFlags, 29),
        // property 'pinnedMessages'
        QtMocHelpers::PropertyData<QStringList>(106, QMetaType::QStringList, QMC::DefaultPropertyFlags, 30),
        // property 'widgetLinks'
        QtMocHelpers::PropertyData<QStringList>(107, QMetaType::QStringList, QMC::DefaultPropertyFlags, 31),
        // property 'roomMemberCount'
        QtMocHelpers::PropertyData<int>(167, QMetaType::Int, QMC::DefaultPropertyFlags, 33),
        // property 'isEncrypted'
        QtMocHelpers::PropertyData<bool>(168, QMetaType::Bool, QMC::DefaultPropertyFlags, 25),
        // property 'fullyReadEventId'
        QtMocHelpers::PropertyData<QString>(169, QMetaType::QString, QMC::DefaultPropertyFlags, 26),
        // property 'isSpace'
        QtMocHelpers::PropertyData<bool>(170, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'trustlevel'
        QtMocHelpers::PropertyData<int>(171, QMetaType::Int, QMC::DefaultPropertyFlags, 27),
        // property 'isDirect'
        QtMocHelpers::PropertyData<bool>(172, QMetaType::Bool, QMC::DefaultPropertyFlags, 34),
        // property 'directChatOtherUserId'
        QtMocHelpers::PropertyData<QString>(173, QMetaType::QString, QMC::DefaultPropertyFlags, 35),
        // property 'input'
        QtMocHelpers::PropertyData<InputBar*>(108, 0x80000000 | 109, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'permissions'
        QtMocHelpers::PropertyData<Permissions*>(110, 0x80000000 | 111, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 36),
        // property 'parentSpace'
        QtMocHelpers::PropertyData<RoomSummary*>(113, 0x80000000 | 114, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 24),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'Roles'
        QtMocHelpers::EnumData<enum Roles>(174, 174, QMC::EnumFlags{}).add({
            {  175, Roles::Type },
            {  176, Roles::TypeString },
            {  177, Roles::IsOnlyEmoji },
            {  178, Roles::Body },
            {  179, Roles::FormattedBody },
            {  180, Roles::FormattedStateEvent },
            {  181, Roles::IsSender },
            {  182, Roles::UserId },
            {  183, Roles::UserName },
            {  184, Roles::UserPowerlevel },
            {  185, Roles::Day },
            {  186, Roles::Timestamp },
            {  187, Roles::Url },
            {  188, Roles::ThumbnailUrl },
            {  189, Roles::Duration },
            {  190, Roles::Blurhash },
            {  191, Roles::Filename },
            {  192, Roles::Filesize },
            {  193, Roles::MimeType },
            {  194, Roles::OriginalHeight },
            {  195, Roles::OriginalWidth },
            {  196, Roles::ProportionalHeight },
            {  197, Roles::EventId },
            {  198, Roles::State },
            {  199, Roles::IsEdited },
            {  200, Roles::IsEditable },
            {  201, Roles::IsEncrypted },
            {  202, Roles::IsStateEvent },
            {  203, Roles::Trustlevel },
            {  204, Roles::Notificationlevel },
            {  205, Roles::EncryptionError },
            {  206, Roles::ReplyTo },
            {  207, Roles::ThreadId },
            {  208, Roles::Reactions },
            {    2, Roles::Room },
            {  209, Roles::RoomId },
            {  210, Roles::RoomName },
            {  211, Roles::RoomTopic },
            {  212, Roles::CallType },
            {  213, Roles::Dump },
            {  214, Roles::RelatedEventCacheBuster },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<TimelineModel, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject TimelineModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QAbstractListModel::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13TimelineModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13TimelineModelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13TimelineModelE_t>.metaTypes,
    nullptr
} };

void TimelineModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<TimelineModel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->dataAtIdChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 1: _t->currentIndexChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 2: _t->redactionFailed((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 3: _t->mediaCached((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 4: _t->newEncryptedImage((*reinterpret_cast<std::add_pointer_t<mtx::crypto::EncryptedFile>>(_a[1]))); break;
        case 5: _t->typingUsersChanged((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 6: _t->replyChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 7: _t->editChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 8: _t->threadChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 9: _t->openReadReceiptsDialog((*reinterpret_cast<std::add_pointer_t<ReadReceiptsProxy*>>(_a[1]))); break;
        case 10: _t->showRawMessageDialog((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 11: _t->paginationInProgressChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 12: _t->newCallEvent((*reinterpret_cast<std::add_pointer_t<mtx::events::collections::TimelineEvents>>(_a[1]))); break;
        case 13: _t->scrollToIndex((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 14: _t->confetti(); break;
        case 15: _t->confettiDone(); break;
        case 16: _t->rainfall(); break;
        case 17: _t->rainfallDone(); break;
        case 18: _t->lastMessageChanged(); break;
        case 19: _t->notificationsChanged(); break;
        case 20: _t->newState((*reinterpret_cast<std::add_pointer_t<mtx::responses::StateEvents>>(_a[1]))); break;
        case 21: _t->newMessageToSend((*reinterpret_cast<std::add_pointer_t<mtx::events::collections::TimelineEvents>>(_a[1]))); break;
        case 22: _t->addPendingMessageToStore((*reinterpret_cast<std::add_pointer_t<mtx::events::collections::TimelineEvents>>(_a[1]))); break;
        case 23: _t->updateFlowEventId((*reinterpret_cast<std::add_pointer_t<std::string>>(_a[1]))); break;
        case 24: _t->parentSpaceChanged(); break;
        case 25: _t->encryptionChanged(); break;
        case 26: _t->fullyReadEventIdChanged(); break;
        case 27: _t->trustlevelChanged(); break;
        case 28: _t->roomNameChanged(); break;
        case 29: _t->roomTopicChanged(); break;
        case 30: _t->pinnedMessagesChanged(); break;
        case 31: _t->widgetLinksChanged(); break;
        case 32: _t->roomAvatarUrlChanged(); break;
        case 33: _t->roomMemberCountChanged(); break;
        case 34: _t->isDirectChanged(); break;
        case 35: _t->directChatOtherUserIdChanged(); break;
        case 36: _t->permissionsChanged(); break;
        case 37: _t->forwardToRoom((*reinterpret_cast<std::add_pointer_t<const mtx::events::collections::TimelineEvents*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 38: _t->scrollTargetChanged(); break;
        case 39: _t->fetchedMore(); break;
        case 40: _t->setCurrentIndex((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 41: _t->setCurrentIndex((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 42: { int _r = _t->currentIndex();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 43: _t->eventShown(); break;
        case 44: _t->markEventsAsRead((*reinterpret_cast<std::add_pointer_t<std::vector<QString>>>(_a[1]))); break;
        case 45: _t->markRoomAsRead(); break;
        case 46: _t->updateLastReadId((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 47: _t->lastReadIdOnWindowFocus(); break;
        case 48: _t->checkAfterFetch(); break;
        case 49: { QVariantMap _r = _t->getDump((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QVariantMap*>(_a[0]) = std::move(_r); }  break;
        case 50: _t->updateTypingUsers((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 51: { QStringList _r = _t->typingUsers();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 52: { bool _r = _t->paginationInProgress();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 53: { QString _r = _t->reply();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 54: _t->setReply((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 55: _t->resetReply(); break;
        case 56: { QString _r = _t->edit();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 57: _t->setEdit((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 58: _t->resetEdit(); break;
        case 59: { QString _r = _t->thread();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 60: _t->setThread((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 61: _t->resetThread(); break;
        case 62: _t->setDecryptDescription((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 63: _t->clearTimeline(); break;
        case 64: _t->resetState(); break;
        case 65: _t->receivedSessionKey((*reinterpret_cast<std::add_pointer_t<std::string>>(_a[1]))); break;
        case 66: { QString _r = _t->roomName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 67: { QString _r = _t->plainRoomName();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 68: { QString _r = _t->roomTopic();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 69: { QStringList _r = _t->pinnedMessages();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 70: { QStringList _r = _t->widgetLinks();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 71: { InputBar* _r = _t->input();
            if (_a[0]) *reinterpret_cast<InputBar**>(_a[0]) = std::move(_r); }  break;
        case 72: { Permissions* _r = _t->permissions();
            if (_a[0]) *reinterpret_cast<Permissions**>(_a[0]) = std::move(_r); }  break;
        case 73: { QString _r = _t->roomAvatarUrl();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 74: { QString _r = _t->roomId();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 75: { RoomSummary* _r = _t->parentSpace();
            if (_a[0]) *reinterpret_cast<RoomSummary**>(_a[0]) = std::move(_r); }  break;
        case 76: { bool _r = _t->hasMentions();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 77: { int _r = _t->notificationCount();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 78: { QString _r = _t->scrollTarget();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 79: _t->triggerSpecialEffects(); break;
        case 80: _t->markSpecialEffectsDone(); break;
        case 81: _t->addPendingMessage((*reinterpret_cast<std::add_pointer_t<mtx::events::collections::TimelineEvents>>(_a[1]))); break;
        case 82: _t->scrollTimerEvent(); break;
        case 83: { QVariant _r = _t->dataById((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QVariant*>(_a[0]) = std::move(_r); }  break;
        case 84: { QVariant _r = _t->dataByIndex((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QVariant*>(_a[0]) = std::move(_r); }  break;
        case 85: { QVariant _r = _t->dataByIndex((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVariant*>(_a[0]) = std::move(_r); }  break;
        case 86: { QString _r = _t->displayName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 87: { QString _r = _t->avatarUrl((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 88: { QString _r = _t->formatDateSeparator((*reinterpret_cast<std::add_pointer_t<QDate>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 89: { QString _r = _t->formatLaterSeparator((*reinterpret_cast<std::add_pointer_t<QDateTime>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDateTime>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 90: { QString _r = _t->formatTypingUsers((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QColor>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 91: { bool _r = _t->showAcceptKnockButton((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 92: _t->acceptKnock((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 93: _t->joinReplacementRoom((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 94: { QString _r = _t->formatMemberEvent((*reinterpret_cast<std::add_pointer_t<mtx::events::StateEvent<mtx::events::state::Member>>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 95: { QString _r = _t->formatPolicyRule((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 96: { QVariantMap _r = _t->formatRedactedEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QVariantMap*>(_a[0]) = std::move(_r); }  break;
        case 97: { bool _r = _t->showImage();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 98: _t->viewRawMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 99: _t->forwardMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 100: _t->viewDecryptedRawMessage((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 101: _t->openUserProfile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 102: _t->unpin((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 103: _t->pin((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 104: _t->showReadReceipts((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 105: _t->redactEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 106: _t->redactEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 107: _t->redactAllFromUser((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 108: _t->redactAllFromUser((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 109: _t->reportEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3]))); break;
        case 110: _t->reportEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 111: _t->reportEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 112: { int _r = _t->idToIndex((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 113: { QString _r = _t->indexToId((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 114: _t->openMedia((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 115: _t->cacheMedia((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 116: { bool _r = _t->saveMedia((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 117: { bool _r = _t->copyMedia((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 118: _t->showEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 119: _t->copyLinkToEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 120: _t->sendReset(); break;
        case 121: _t->requestKeyForEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(QString )>(_a, &TimelineModel::dataAtIdChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(int )>(_a, &TimelineModel::currentIndexChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(QString )>(_a, &TimelineModel::redactionFailed, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(QString , QString )>(_a, &TimelineModel::mediaCached, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(mtx::crypto::EncryptedFile )>(_a, &TimelineModel::newEncryptedImage, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(QStringList )>(_a, &TimelineModel::typingUsersChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(QString )>(_a, &TimelineModel::replyChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(QString )>(_a, &TimelineModel::editChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(QString )>(_a, &TimelineModel::threadChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(ReadReceiptsProxy * )>(_a, &TimelineModel::openReadReceiptsDialog, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(QString )>(_a, &TimelineModel::showRawMessageDialog, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(const bool )>(_a, &TimelineModel::paginationInProgressChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(const mtx::events::collections::TimelineEvents & )>(_a, &TimelineModel::newCallEvent, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(int )>(_a, &TimelineModel::scrollToIndex, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::confetti, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::confettiDone, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::rainfall, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::rainfallDone, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::lastMessageChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::notificationsChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(const mtx::responses::StateEvents & )>(_a, &TimelineModel::newState, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(mtx::events::collections::TimelineEvents )>(_a, &TimelineModel::newMessageToSend, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(mtx::events::collections::TimelineEvents )>(_a, &TimelineModel::addPendingMessageToStore, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(std::string )>(_a, &TimelineModel::updateFlowEventId, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::parentSpaceChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::encryptionChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::fullyReadEventIdChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::trustlevelChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::roomNameChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::roomTopicChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::pinnedMessagesChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::widgetLinksChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::roomAvatarUrlChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::roomMemberCountChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::isDirectChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::directChatOtherUserIdChanged, 35))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::permissionsChanged, 36))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)(mtx::events::collections::TimelineEvents const * , QString )>(_a, &TimelineModel::forwardToRoom, 37))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::scrollTargetChanged, 38))
            return;
        if (QtMocHelpers::indexOfMethod<void (TimelineModel::*)()>(_a, &TimelineModel::fetchedMore, 39))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 21:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< InputBar* >(); break;
        case 22:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Permissions* >(); break;
        case 23:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< RoomSummary* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<int*>(_v) = _t->currentIndex(); break;
        case 1: *reinterpret_cast<QStringList*>(_v) = _t->typingUsers(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->scrollTarget(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->reply(); break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->edit(); break;
        case 5: *reinterpret_cast<QString*>(_v) = _t->thread(); break;
        case 6: *reinterpret_cast<bool*>(_v) = _t->paginationInProgress(); break;
        case 7: *reinterpret_cast<QString*>(_v) = _t->roomId(); break;
        case 8: *reinterpret_cast<QString*>(_v) = _t->roomName(); break;
        case 9: *reinterpret_cast<QString*>(_v) = _t->plainRoomName(); break;
        case 10: *reinterpret_cast<QString*>(_v) = _t->roomAvatarUrl(); break;
        case 11: *reinterpret_cast<QString*>(_v) = _t->roomTopic(); break;
        case 12: *reinterpret_cast<QStringList*>(_v) = _t->pinnedMessages(); break;
        case 13: *reinterpret_cast<QStringList*>(_v) = _t->widgetLinks(); break;
        case 14: *reinterpret_cast<int*>(_v) = _t->roomMemberCount(); break;
        case 15: *reinterpret_cast<bool*>(_v) = _t->isEncrypted(); break;
        case 16: *reinterpret_cast<QString*>(_v) = _t->fullyReadEventId(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->isSpace(); break;
        case 18: *reinterpret_cast<int*>(_v) = _t->trustlevel(); break;
        case 19: *reinterpret_cast<bool*>(_v) = _t->isDirect(); break;
        case 20: *reinterpret_cast<QString*>(_v) = _t->directChatOtherUserId(); break;
        case 21: *reinterpret_cast<InputBar**>(_v) = _t->input(); break;
        case 22: *reinterpret_cast<Permissions**>(_v) = _t->permissions(); break;
        case 23: *reinterpret_cast<RoomSummary**>(_v) = _t->parentSpace(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setCurrentIndex(*reinterpret_cast<int*>(_v)); break;
        case 1: _t->updateTypingUsers(*reinterpret_cast<QStringList*>(_v)); break;
        case 3: _t->setReply(*reinterpret_cast<QString*>(_v)); break;
        case 4: _t->setEdit(*reinterpret_cast<QString*>(_v)); break;
        case 5: _t->setThread(*reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
    if (_c == QMetaObject::ResetProperty) {
        switch (_id) {
        case 3: _t->resetReply(); break;
        case 4: _t->resetEdit(); break;
        case 5: _t->resetThread(); break;
        default: break;
        }
    }
}

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

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

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

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

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

// SIGNAL 2
void TimelineModel::redactionFailed(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void TimelineModel::mediaCached(QString _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1, _t2);
}

// SIGNAL 4
void TimelineModel::newEncryptedImage(mtx::crypto::EncryptedFile _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void TimelineModel::typingUsersChanged(QStringList _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

// SIGNAL 6
void TimelineModel::replyChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void TimelineModel::editChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void TimelineModel::threadChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void TimelineModel::openReadReceiptsDialog(ReadReceiptsProxy * _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

// SIGNAL 10
void TimelineModel::showRawMessageDialog(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

// SIGNAL 11
void TimelineModel::paginationInProgressChanged(const bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void TimelineModel::newCallEvent(const mtx::events::collections::TimelineEvents & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void TimelineModel::scrollToIndex(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void TimelineModel::confetti()
{
    QMetaObject::activate(this, &staticMetaObject, 14, nullptr);
}

// SIGNAL 15
void TimelineModel::confettiDone()
{
    QMetaObject::activate(this, &staticMetaObject, 15, nullptr);
}

// SIGNAL 16
void TimelineModel::rainfall()
{
    QMetaObject::activate(this, &staticMetaObject, 16, nullptr);
}

// SIGNAL 17
void TimelineModel::rainfallDone()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}

// SIGNAL 18
void TimelineModel::lastMessageChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 18, nullptr);
}

// SIGNAL 19
void TimelineModel::notificationsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 19, nullptr);
}

// SIGNAL 20
void TimelineModel::newState(const mtx::responses::StateEvents & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void TimelineModel::newMessageToSend(mtx::events::collections::TimelineEvents _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void TimelineModel::addPendingMessageToStore(mtx::events::collections::TimelineEvents _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void TimelineModel::updateFlowEventId(std::string _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void TimelineModel::parentSpaceChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 24, nullptr);
}

// SIGNAL 25
void TimelineModel::encryptionChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 25, nullptr);
}

// SIGNAL 26
void TimelineModel::fullyReadEventIdChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 26, nullptr);
}

// SIGNAL 27
void TimelineModel::trustlevelChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 27, nullptr);
}

// SIGNAL 28
void TimelineModel::roomNameChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 28, nullptr);
}

// SIGNAL 29
void TimelineModel::roomTopicChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 29, nullptr);
}

// SIGNAL 30
void TimelineModel::pinnedMessagesChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 30, nullptr);
}

// SIGNAL 31
void TimelineModel::widgetLinksChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 31, nullptr);
}

// SIGNAL 32
void TimelineModel::roomAvatarUrlChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 32, nullptr);
}

// SIGNAL 33
void TimelineModel::roomMemberCountChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 33, nullptr);
}

// SIGNAL 34
void TimelineModel::isDirectChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 34, nullptr);
}

// SIGNAL 35
void TimelineModel::directChatOtherUserIdChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 35, nullptr);
}

// SIGNAL 36
void TimelineModel::permissionsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 36, nullptr);
}

// SIGNAL 37
void TimelineModel::forwardToRoom(mtx::events::collections::TimelineEvents const * _t1, QString _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 37, nullptr, _t1, _t2);
}

// SIGNAL 38
void TimelineModel::scrollTargetChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 38, nullptr);
}

// SIGNAL 39
void TimelineModel::fetchedMore()
{
    QMetaObject::activate(this, &staticMetaObject, 39, nullptr);
}
namespace {
struct qt_meta_tag_ZN14qml_mtx_eventsE_t {};
} // unnamed namespace

template <> constexpr inline auto qml_mtx_events::qt_create_metaobjectdata<qt_meta_tag_ZN14qml_mtx_eventsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "qml_mtx_events",
        "QML.Element",
        "MtxEvent",
        "EventType",
        "Unsupported",
        "KeyRequest",
        "Reaction",
        "Aliases",
        "Avatar",
        "CallInvite",
        "CallAnswer",
        "CallHangUp",
        "CallCandidates",
        "CallSelectAnswer",
        "CallReject",
        "CallNegotiate",
        "CanonicalAlias",
        "RoomCreate",
        "Encrypted",
        "Encryption",
        "RoomGuestAccess",
        "RoomHistoryVisibility",
        "RoomJoinRules",
        "Member",
        "Name",
        "PowerLevels",
        "Tombstone",
        "ServerAcl",
        "Topic",
        "Redaction",
        "PinnedEvents",
        "Sticker",
        "Tag",
        "Widget",
        "AudioMessage",
        "ElementEffectMessage",
        "EmoteMessage",
        "FileMessage",
        "ImageMessage",
        "LocationMessage",
        "NoticeMessage",
        "TextMessage",
        "UnknownMessage",
        "VideoMessage",
        "Redacted",
        "UnknownEvent",
        "KeyVerificationRequest",
        "KeyVerificationStart",
        "KeyVerificationMac",
        "KeyVerificationAccept",
        "KeyVerificationCancel",
        "KeyVerificationKey",
        "KeyVerificationDone",
        "KeyVerificationReady",
        "ImagePackInRoom",
        "ImagePackInAccountData",
        "ImagePackRooms",
        "PolicyRuleUser",
        "PolicyRuleRoom",
        "PolicyRuleServer",
        "SpaceParent",
        "SpaceChild",
        "EventState",
        "Received",
        "Read",
        "Sent",
        "Failed",
        "Empty",
        "NotificationLevel",
        "Nothing",
        "Notify",
        "Highlight"
    };

    QtMocHelpers::UintData qt_methods {
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'EventType'
        QtMocHelpers::EnumData<EventType>(3, 3, QMC::EnumFlags{}).add({
            {    4, EventType::Unsupported },
            {    5, EventType::KeyRequest },
            {    6, EventType::Reaction },
            {    7, EventType::Aliases },
            {    8, EventType::Avatar },
            {    9, EventType::CallInvite },
            {   10, EventType::CallAnswer },
            {   11, EventType::CallHangUp },
            {   12, EventType::CallCandidates },
            {   13, EventType::CallSelectAnswer },
            {   14, EventType::CallReject },
            {   15, EventType::CallNegotiate },
            {   16, EventType::CanonicalAlias },
            {   17, EventType::RoomCreate },
            {   18, EventType::Encrypted },
            {   19, EventType::Encryption },
            {   20, EventType::RoomGuestAccess },
            {   21, EventType::RoomHistoryVisibility },
            {   22, EventType::RoomJoinRules },
            {   23, EventType::Member },
            {   24, EventType::Name },
            {   25, EventType::PowerLevels },
            {   26, EventType::Tombstone },
            {   27, EventType::ServerAcl },
            {   28, EventType::Topic },
            {   29, EventType::Redaction },
            {   30, EventType::PinnedEvents },
            {   31, EventType::Sticker },
            {   32, EventType::Tag },
            {   33, EventType::Widget },
            {   34, EventType::AudioMessage },
            {   35, EventType::ElementEffectMessage },
            {   36, EventType::EmoteMessage },
            {   37, EventType::FileMessage },
            {   38, EventType::ImageMessage },
            {   39, EventType::LocationMessage },
            {   40, EventType::NoticeMessage },
            {   41, EventType::TextMessage },
            {   42, EventType::UnknownMessage },
            {   43, EventType::VideoMessage },
            {   44, EventType::Redacted },
            {   45, EventType::UnknownEvent },
            {   46, EventType::KeyVerificationRequest },
            {   47, EventType::KeyVerificationStart },
            {   48, EventType::KeyVerificationMac },
            {   49, EventType::KeyVerificationAccept },
            {   50, EventType::KeyVerificationCancel },
            {   51, EventType::KeyVerificationKey },
            {   52, EventType::KeyVerificationDone },
            {   53, EventType::KeyVerificationReady },
            {   54, EventType::ImagePackInRoom },
            {   55, EventType::ImagePackInAccountData },
            {   56, EventType::ImagePackRooms },
            {   57, EventType::PolicyRuleUser },
            {   58, EventType::PolicyRuleRoom },
            {   59, EventType::PolicyRuleServer },
            {   60, EventType::SpaceParent },
            {   61, EventType::SpaceChild },
        }),
        // enum 'EventState'
        QtMocHelpers::EnumData<EventState>(62, 62, QMC::EnumFlags{}).add({
            {   63, EventState::Received },
            {   64, EventState::Read },
            {   65, EventState::Sent },
            {   66, EventState::Failed },
            {   67, EventState::Empty },
        }),
        // enum 'NotificationLevel'
        QtMocHelpers::EnumData<NotificationLevel>(68, 68, QMC::EnumFlags{}).add({
            {   69, NotificationLevel::Nothing },
            {   70, NotificationLevel::Notify },
            {   71, NotificationLevel::Highlight },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<void, qt_meta_tag_ZN14qml_mtx_eventsE_t>(QMC::PropertyAccessInStaticMetaCall, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}

static constexpr auto qt_staticMetaObjectContent_ZN14qml_mtx_eventsE =
    qml_mtx_events::qt_create_metaobjectdata<qt_meta_tag_ZN14qml_mtx_eventsE_t>();
static constexpr auto qt_staticMetaObjectStaticContent_ZN14qml_mtx_eventsE =
    qt_staticMetaObjectContent_ZN14qml_mtx_eventsE.staticData;
static constexpr auto qt_staticMetaObjectRelocatingContent_ZN14qml_mtx_eventsE =
    qt_staticMetaObjectContent_ZN14qml_mtx_eventsE.relocatingData;

Q_CONSTINIT const QMetaObject qml_mtx_events::staticMetaObject = { {
    nullptr,
    qt_staticMetaObjectStaticContent_ZN14qml_mtx_eventsE.stringdata,
    qt_staticMetaObjectStaticContent_ZN14qml_mtx_eventsE.data,
    nullptr,
    nullptr,
    qt_staticMetaObjectRelocatingContent_ZN14qml_mtx_eventsE.metaTypes,
    nullptr
} };

QT_WARNING_POP
