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

#include "../../../../../neochat-26.07.80/src/libneochat/neochatroom.h"
#include <QtNetwork/QSslError>
#include <QtCore/qmetatype.h>
#include <QtCore/QList>

#include <QtCore/qtmochelpers.h>

#include <memory>


#include <QtCore/qxptype_traits.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'neochatroom.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.12.0. 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_ZN11NeoChatRoomE_t {};
} // unnamed namespace

template <> constexpr inline auto NeoChatRoom::qt_create_metaobjectdata<qt_meta_tag_ZN11NeoChatRoomE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "NeoChatRoom",
        "QML.Element",
        "auto",
        "QML.Creatable",
        "false",
        "QML.UncreatableReason",
        "",
        "cachedInputChanged",
        "busyChanged",
        "hasFileUploadingChanged",
        "fileUploadingProgressChanged",
        "backgroundChanged",
        "readMarkerLoadedChanged",
        "parentIdsChanged",
        "canonicalParentChanged",
        "lastActiveTimeChanged",
        "childrenNotificationCountChanged",
        "childrenHaveHighlightNotificationsChanged",
        "isInviteChanged",
        "readOnlyChanged",
        "displayNameChanged",
        "pushNotificationStateChanged",
        "PushNotificationState::State",
        "state",
        "canEncryptRoomChanged",
        "historyVisibilityChanged",
        "defaultUrlPreviewStateChanged",
        "urlPreviewEnabledChanged",
        "maxRoomVersionChanged",
        "extraEventLoaded",
        "eventId",
        "extraEventNotFound",
        "inviteTimestampChanged",
        "pinnedMessageChanged",
        "highlightCycleStartedChanged",
        "spaceHasUnreadMessagesChanged",
        "joinRuleStringChanged",
        "showMessage",
        "MessageType::Type",
        "messageType",
        "message",
        "updatePushNotificationState",
        "type",
        "cacheLastEvent",
        "invalidateLastUnreadHighlightId",
        "fromEventId",
        "toEventId",
        "insertMemberSorted",
        "Quotient::RoomMember",
        "member",
        "uploadFile",
        "QUrl",
        "url",
        "body",
        "std::optional<Quotient::EventRelation>",
        "relatesTo",
        "acceptInvitation",
        "forget",
        "sendTypingNotification",
        "isTyping",
        "changeAvatar",
        "localFile",
        "toggleReaction",
        "reaction",
        "deleteMessagesByUser",
        "user",
        "reason",
        "sendLocation",
        "lat",
        "lon",
        "description",
        "download",
        "localFilename",
        "downloadTempFile",
        "containsUser",
        "userID",
        "isUserBanned",
        "canSendEvent",
        "eventType",
        "canSendState",
        "reportEvent",
        "getEventJsonSource",
        "openEventMediaExternally",
        "copyEventMedia",
        "hasParent",
        "parentObjects",
        "QList<NeoChatRoom*>",
        "multiLevel",
        "canModifyParent",
        "parentId",
        "addParent",
        "canonical",
        "setParentChild",
        "removeParent",
        "addChild",
        "childId",
        "setChildParent",
        "suggested",
        "order",
        "removeChild",
        "unsetChildParent",
        "isSuggested",
        "toggleChildSuggested",
        "mapAlias",
        "alias",
        "unmapAlias",
        "setCanonicalAlias",
        "newAlias",
        "setRoomState",
        "stateKey",
        "content",
        "setUserPowerLevel",
        "powerLevel",
        "cacheForType",
        "ChatBarCache*",
        "ChatBarType::Type",
        "editLastMessage",
        "postPoll",
        "PollKind::Kind",
        "kind",
        "question",
        "answers",
        "roomAcountDataJson",
        "findEvent",
        "const Quotient::RoomEvent*",
        "qmlSafeMember",
        "NeochatRoomMember*",
        "memberId",
        "pinEvent",
        "unpinEvent",
        "isEventPinned",
        "eventIsThreaded",
        "rootIdForThread",
        "roomCreatorHasUltimatePowerLevel",
        "isCreator",
        "userId",
        "report",
        "findNextUnreadHighlightId",
        "markAllChildrenMessagesAsRead",
        "sendPublicReceipts",
        "markAllMessagesAsRead",
        "setJoinRuleString",
        "joinRule",
        "allowedSpaces",
        "forwardMessage",
        "NeoChatRoom*",
        "targetRoom",
        "avatarChanged",
        "baseStateLoaded",
        "lastActiveTime",
        "hasFileUploading",
        "fileUploadingProgress",
        "readMarkerLoaded",
        "avatarMediaUrl",
        "directChatRemoteMember",
        "parentIds",
        "canonicalParent",
        "isSpace",
        "childrenNotificationCount",
        "qsizetype",
        "childrenHaveHighlightNotifications",
        "isInvite",
        "readOnly",
        "maxRoomVersion",
        "pushNotificationState",
        "historyVisibility",
        "defaultUrlPreviewState",
        "urlPreviewEnabled",
        "canEncryptRoom",
        "mainCache",
        "editCache",
        "threadCache",
        "inviteTimestamp",
        "invitingUserId",
        "pinnedMessage",
        "highlightCycleStarted",
        "spaceHasUnreadMessages",
        "joinRuleString",
        "allowIds"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'cachedInputChanged'
        QtMocHelpers::SignalData<void()>(7, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'busyChanged'
        QtMocHelpers::SignalData<void()>(8, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'hasFileUploadingChanged'
        QtMocHelpers::SignalData<void()>(9, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'fileUploadingProgressChanged'
        QtMocHelpers::SignalData<void()>(10, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'backgroundChanged'
        QtMocHelpers::SignalData<void()>(11, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'readMarkerLoadedChanged'
        QtMocHelpers::SignalData<void()>(12, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'parentIdsChanged'
        QtMocHelpers::SignalData<void()>(13, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'canonicalParentChanged'
        QtMocHelpers::SignalData<void()>(14, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lastActiveTimeChanged'
        QtMocHelpers::SignalData<void()>(15, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'childrenNotificationCountChanged'
        QtMocHelpers::SignalData<void()>(16, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'childrenHaveHighlightNotificationsChanged'
        QtMocHelpers::SignalData<void()>(17, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'isInviteChanged'
        QtMocHelpers::SignalData<void()>(18, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'readOnlyChanged'
        QtMocHelpers::SignalData<void()>(19, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'displayNameChanged'
        QtMocHelpers::SignalData<void()>(20, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'pushNotificationStateChanged'
        QtMocHelpers::SignalData<void(PushNotificationState::State)>(21, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 22, 23 },
        }}),
        // Signal 'canEncryptRoomChanged'
        QtMocHelpers::SignalData<void()>(24, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'historyVisibilityChanged'
        QtMocHelpers::SignalData<void()>(25, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'defaultUrlPreviewStateChanged'
        QtMocHelpers::SignalData<void()>(26, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'urlPreviewEnabledChanged'
        QtMocHelpers::SignalData<void()>(27, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'maxRoomVersionChanged'
        QtMocHelpers::SignalData<void()>(28, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'extraEventLoaded'
        QtMocHelpers::SignalData<void(const QString &)>(29, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 30 },
        }}),
        // Signal 'extraEventNotFound'
        QtMocHelpers::SignalData<void(const QString &)>(31, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 30 },
        }}),
        // Signal 'inviteTimestampChanged'
        QtMocHelpers::SignalData<void()>(32, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'pinnedMessageChanged'
        QtMocHelpers::SignalData<void()>(33, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'highlightCycleStartedChanged'
        QtMocHelpers::SignalData<void()>(34, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'spaceHasUnreadMessagesChanged'
        QtMocHelpers::SignalData<void()>(35, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'joinRuleStringChanged'
        QtMocHelpers::SignalData<void()>(36, 6, QMC::AccessPublic, QMetaType::Void),
        // Signal 'showMessage'
        QtMocHelpers::SignalData<void(MessageType::Type, const QString &)>(37, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 38, 39 }, { QMetaType::QString, 40 },
        }}),
        // Slot 'updatePushNotificationState'
        QtMocHelpers::SlotData<void(QString)>(41, 6, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 42 },
        }}),
        // Slot 'cacheLastEvent'
        QtMocHelpers::SlotData<void()>(43, 6, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'invalidateLastUnreadHighlightId'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(44, 6, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 45 }, { QMetaType::QString, 46 },
        }}),
        // Slot 'insertMemberSorted'
        QtMocHelpers::SlotData<void(Quotient::RoomMember)>(47, 6, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 48, 49 },
        }}),
        // Slot 'uploadFile'
        QtMocHelpers::SlotData<void(const QUrl &, const QString &, std::optional<Quotient::EventRelation>)>(50, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 51, 52 }, { QMetaType::QString, 53 }, { 0x80000000 | 54, 55 },
        }}),
        // Slot 'uploadFile'
        QtMocHelpers::SlotData<void(const QUrl &, const QString &)>(50, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 51, 52 }, { QMetaType::QString, 53 },
        }}),
        // Slot 'uploadFile'
        QtMocHelpers::SlotData<void(const QUrl &)>(50, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { 0x80000000 | 51, 52 },
        }}),
        // Slot 'acceptInvitation'
        QtMocHelpers::SlotData<void()>(56, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'forget'
        QtMocHelpers::SlotData<void()>(57, 6, QMC::AccessPublic, QMetaType::Void),
        // Slot 'sendTypingNotification'
        QtMocHelpers::SlotData<void(bool)>(58, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 59 },
        }}),
        // Slot 'changeAvatar'
        QtMocHelpers::SlotData<void(const QUrl &)>(60, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 51, 61 },
        }}),
        // Slot 'toggleReaction'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(62, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 30 }, { QMetaType::QString, 63 },
        }}),
        // Slot 'deleteMessagesByUser'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(64, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 65 }, { QMetaType::QString, 66 },
        }}),
        // Slot 'sendLocation'
        QtMocHelpers::SlotData<void(float, float, const QString &)>(67, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Float, 68 }, { QMetaType::Float, 69 }, { QMetaType::QString, 70 },
        }}),
        // Method 'download'
        QtMocHelpers::MethodData<void(const QString &, const QUrl &)>(71, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 30 }, { 0x80000000 | 51, 72 },
        }}),
        // Method 'download'
        QtMocHelpers::MethodData<void(const QString &)>(71, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 30 },
        }}),
        // Method 'downloadTempFile'
        QtMocHelpers::MethodData<bool(const QString &)>(73, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 30 },
        }}),
        // Method 'containsUser'
        QtMocHelpers::MethodData<bool(const QString &) const>(74, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 75 },
        }}),
        // Method 'isUserBanned'
        QtMocHelpers::MethodData<bool(const QString &) const>(76, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 65 },
        }}),
        // Method 'canSendEvent'
        QtMocHelpers::MethodData<bool(const QString &) const>(77, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 78 },
        }}),
        // Method 'canSendState'
        QtMocHelpers::MethodData<bool(const QString &) const>(79, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 78 },
        }}),
        // Method 'reportEvent'
        QtMocHelpers::MethodData<void(const QString &, const QString &)>(80, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 30 }, { QMetaType::QString, 66 },
        }}),
        // Method 'getEventJsonSource'
        QtMocHelpers::MethodData<QByteArray(const QString &)>(81, 6, QMC::AccessPublic, QMetaType::QByteArray, {{
            { QMetaType::QString, 30 },
        }}),
        // Method 'openEventMediaExternally'
        QtMocHelpers::MethodData<void(const QString &)>(82, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 30 },
        }}),
        // Method 'copyEventMedia'
        QtMocHelpers::MethodData<void(const QString &)>(83, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 30 },
        }}),
        // Method 'hasParent'
        QtMocHelpers::MethodData<bool() const>(84, 6, QMC::AccessPublic, QMetaType::Bool),
        // Method 'parentObjects'
        QtMocHelpers::MethodData<QList<NeoChatRoom*>(bool) const>(85, 6, QMC::AccessPublic, 0x80000000 | 86, {{
            { QMetaType::Bool, 87 },
        }}),
        // Method 'parentObjects'
        QtMocHelpers::MethodData<QList<NeoChatRoom*>() const>(85, 6, QMC::AccessPublic | QMC::MethodCloned, 0x80000000 | 86),
        // Method 'canModifyParent'
        QtMocHelpers::MethodData<bool(const QString &) const>(88, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 89 },
        }}),
        // Method 'addParent'
        QtMocHelpers::MethodData<void(const QString &, bool, bool)>(90, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 89 }, { QMetaType::Bool, 91 }, { QMetaType::Bool, 92 },
        }}),
        // Method 'addParent'
        QtMocHelpers::MethodData<void(const QString &, bool)>(90, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 89 }, { QMetaType::Bool, 91 },
        }}),
        // Method 'addParent'
        QtMocHelpers::MethodData<void(const QString &)>(90, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 89 },
        }}),
        // Method 'removeParent'
        QtMocHelpers::MethodData<void(const QString &)>(93, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 89 },
        }}),
        // Method 'addChild'
        QtMocHelpers::MethodData<void(const QString &, bool, bool, bool, const QString &)>(94, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 95 }, { QMetaType::Bool, 96 }, { QMetaType::Bool, 91 }, { QMetaType::Bool, 97 },
            { QMetaType::QString, 98 },
        }}),
        // Method 'addChild'
        QtMocHelpers::MethodData<void(const QString &, bool, bool, bool)>(94, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 95 }, { QMetaType::Bool, 96 }, { QMetaType::Bool, 91 }, { QMetaType::Bool, 97 },
        }}),
        // Method 'addChild'
        QtMocHelpers::MethodData<void(const QString &, bool, bool)>(94, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 95 }, { QMetaType::Bool, 96 }, { QMetaType::Bool, 91 },
        }}),
        // Method 'addChild'
        QtMocHelpers::MethodData<void(const QString &, bool)>(94, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 95 }, { QMetaType::Bool, 96 },
        }}),
        // Method 'addChild'
        QtMocHelpers::MethodData<void(const QString &)>(94, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 95 },
        }}),
        // Method 'removeChild'
        QtMocHelpers::MethodData<void(const QString &, bool)>(99, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 95 }, { QMetaType::Bool, 100 },
        }}),
        // Method 'removeChild'
        QtMocHelpers::MethodData<void(const QString &)>(99, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 95 },
        }}),
        // Method 'isSuggested'
        QtMocHelpers::MethodData<bool(const QString &)>(101, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 95 },
        }}),
        // Method 'toggleChildSuggested'
        QtMocHelpers::MethodData<void(const QString &)>(102, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 95 },
        }}),
        // Method 'mapAlias'
        QtMocHelpers::MethodData<void(const QString &)>(103, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 104 },
        }}),
        // Method 'unmapAlias'
        QtMocHelpers::MethodData<void(const QString &)>(105, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 104 },
        }}),
        // Method 'setCanonicalAlias'
        QtMocHelpers::MethodData<void(const QString &)>(106, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 107 },
        }}),
        // Method 'setRoomState'
        QtMocHelpers::MethodData<void(const QString &, const QString &, const QByteArray &)>(108, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 42 }, { QMetaType::QString, 109 }, { QMetaType::QByteArray, 110 },
        }}),
        // Method 'setUserPowerLevel'
        QtMocHelpers::MethodData<void(const QString &, const int &)>(111, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 75 }, { QMetaType::Int, 112 },
        }}),
        // Method 'cacheForType'
        QtMocHelpers::MethodData<ChatBarCache *(ChatBarType::Type) const>(113, 6, QMC::AccessPublic, 0x80000000 | 114, {{
            { 0x80000000 | 115, 42 },
        }}),
        // Method 'editLastMessage'
        QtMocHelpers::MethodData<void()>(116, 6, QMC::AccessPublic, QMetaType::Void),
        // Method 'postPoll'
        QtMocHelpers::MethodData<void(PollKind::Kind, const QString &, const QList<QString> &)>(117, 6, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 118, 119 }, { QMetaType::QString, 120 }, { QMetaType::QStringList, 121 },
        }}),
        // Method 'roomAcountDataJson'
        QtMocHelpers::MethodData<QByteArray(const QString &)>(122, 6, QMC::AccessPublic, QMetaType::QByteArray, {{
            { QMetaType::QString, 78 },
        }}),
        // Method 'findEvent'
        QtMocHelpers::MethodData<const Quotient::RoomEvent *(const QString &) const>(123, 6, QMC::AccessPublic, 0x80000000 | 124, {{
            { QMetaType::QString, 30 },
        }}),
        // Method 'qmlSafeMember'
        QtMocHelpers::MethodData<NeochatRoomMember *(const QString &)>(125, 6, QMC::AccessPublic, 0x80000000 | 126, {{
            { QMetaType::QString, 127 },
        }}),
        // Method 'pinEvent'
        QtMocHelpers::MethodData<void(const QString &)>(128, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 30 },
        }}),
        // Method 'unpinEvent'
        QtMocHelpers::MethodData<void(const QString &)>(129, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 30 },
        }}),
        // Method 'isEventPinned'
        QtMocHelpers::MethodData<bool(const QString &) const>(130, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 30 },
        }}),
        // Method 'eventIsThreaded'
        QtMocHelpers::MethodData<bool(const QString &) const>(131, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 30 },
        }}),
        // Method 'rootIdForThread'
        QtMocHelpers::MethodData<QString(const QString &) const>(132, 6, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 30 },
        }}),
        // Method 'roomCreatorHasUltimatePowerLevel'
        QtMocHelpers::MethodData<bool() const>(133, 6, QMC::AccessPublic, QMetaType::Bool),
        // Method 'isCreator'
        QtMocHelpers::MethodData<bool(const QString &) const>(134, 6, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 135 },
        }}),
        // Method 'report'
        QtMocHelpers::MethodData<void(const QString &)>(136, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 66 },
        }}),
        // Method 'findNextUnreadHighlightId'
        QtMocHelpers::MethodData<QString()>(137, 6, QMC::AccessPublic, QMetaType::QString),
        // Method 'markAllChildrenMessagesAsRead'
        QtMocHelpers::MethodData<void(bool)>(138, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 139 },
        }}),
        // Method 'markAllMessagesAsRead'
        QtMocHelpers::MethodData<void(bool)>(140, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 139 },
        }}),
        // Method 'markAllMessagesAsRead'
        QtMocHelpers::MethodData<void()>(140, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Method 'setJoinRuleString'
        QtMocHelpers::MethodData<void(const QString &, const QList<QString> &)>(141, 6, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 142 }, { QMetaType::QStringList, 143 },
        }}),
        // Method 'setJoinRuleString'
        QtMocHelpers::MethodData<void(const QString &)>(141, 6, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void, {{
            { QMetaType::QString, 142 },
        }}),
        // Method 'forwardMessage'
        QtMocHelpers::MethodData<QString(NeoChatRoom *, const QString &)>(144, 6, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 145, 146 }, { QMetaType::QString, 30 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'lastActiveTime'
        QtMocHelpers::PropertyData<QDateTime>(149, QMetaType::QDateTime, QMC::DefaultPropertyFlags, 8),
        // property 'hasFileUploading'
        QtMocHelpers::PropertyData<bool>(150, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'fileUploadingProgress'
        QtMocHelpers::PropertyData<int>(151, QMetaType::Int, QMC::DefaultPropertyFlags, 3),
        // property 'readMarkerLoaded'
        QtMocHelpers::PropertyData<bool>(152, QMetaType::Bool, QMC::DefaultPropertyFlags, 5),
        // property 'avatarMediaUrl'
        QtMocHelpers::PropertyData<QUrl>(153, 0x80000000 | 51, QMC::Readable | QMC::Designable | QMC::Scriptable | QMC::EnumOrFlag, 0x70000000 | 147),
        // property 'directChatRemoteMember'
        QtMocHelpers::PropertyData<NeochatRoomMember*>(154, 0x80000000 | 126, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'parentIds'
        QtMocHelpers::PropertyData<QList<QString>>(155, QMetaType::QStringList, QMC::DefaultPropertyFlags, 6),
        // property 'canonicalParent'
        QtMocHelpers::PropertyData<QString>(156, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 7),
        // property 'isSpace'
        QtMocHelpers::PropertyData<bool>(157, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Constant),
        // property 'childrenNotificationCount'
        QtMocHelpers::PropertyData<qsizetype>(158, 0x80000000 | 159, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 9),
        // property 'childrenHaveHighlightNotifications'
        QtMocHelpers::PropertyData<bool>(160, QMetaType::Bool, QMC::DefaultPropertyFlags, 10),
        // property 'isInvite'
        QtMocHelpers::PropertyData<bool>(161, QMetaType::Bool, QMC::DefaultPropertyFlags, 11),
        // property 'readOnly'
        QtMocHelpers::PropertyData<bool>(162, QMetaType::Bool, QMC::DefaultPropertyFlags, 12),
        // property 'maxRoomVersion'
        QtMocHelpers::PropertyData<int>(163, QMetaType::Int, QMC::DefaultPropertyFlags, 19),
        // property 'pushNotificationState'
        QtMocHelpers::PropertyData<PushNotificationState::State>(164, 0x80000000 | 22, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 14),
        // property 'historyVisibility'
        QtMocHelpers::PropertyData<QString>(165, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'defaultUrlPreviewState'
        QtMocHelpers::PropertyData<bool>(166, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'urlPreviewEnabled'
        QtMocHelpers::PropertyData<bool>(167, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'canEncryptRoom'
        QtMocHelpers::PropertyData<bool>(168, QMetaType::Bool, QMC::DefaultPropertyFlags, 15),
        // property 'mainCache'
        QtMocHelpers::PropertyData<ChatBarCache*>(169, 0x80000000 | 114, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'editCache'
        QtMocHelpers::PropertyData<ChatBarCache*>(170, 0x80000000 | 114, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'threadCache'
        QtMocHelpers::PropertyData<ChatBarCache*>(171, 0x80000000 | 114, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'inviteTimestamp'
        QtMocHelpers::PropertyData<QDateTime>(172, QMetaType::QDateTime, QMC::DefaultPropertyFlags, 0x70000000 | 148),
        // property 'invitingUserId'
        QtMocHelpers::PropertyData<QString>(173, QMetaType::QString, QMC::DefaultPropertyFlags, 0x70000000 | 148),
        // property 'pinnedMessage'
        QtMocHelpers::PropertyData<QString>(174, QMetaType::QString, QMC::DefaultPropertyFlags, 23),
        // property 'highlightCycleStarted'
        QtMocHelpers::PropertyData<bool>(175, QMetaType::Bool, QMC::DefaultPropertyFlags, 24),
        // property 'spaceHasUnreadMessages'
        QtMocHelpers::PropertyData<bool>(176, QMetaType::Bool, QMC::DefaultPropertyFlags, 25),
        // property 'joinRuleString'
        QtMocHelpers::PropertyData<QString>(177, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 26),
        // property 'allowIds'
        QtMocHelpers::PropertyData<QList<QString>>(178, QMetaType::QStringList, QMC::DefaultPropertyFlags, 26),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
            {    3,    4 },
            {    5,    6 },
    });
    return QtMocHelpers::metaObjectData<NeoChatRoom, void>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN11NeoChatRoomE[] = {
    QMetaObject::SuperData::link<PushNotificationState::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject NeoChatRoom::staticMetaObject = { {
    QMetaObject::SuperData::link<Quotient::Room::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11NeoChatRoomE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11NeoChatRoomE_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN11NeoChatRoomE,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN11NeoChatRoomE_t>.metaTypes,
    nullptr
} };

void NeoChatRoom::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<NeoChatRoom *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->cachedInputChanged(); break;
        case 1: _t->busyChanged(); break;
        case 2: _t->hasFileUploadingChanged(); break;
        case 3: _t->fileUploadingProgressChanged(); break;
        case 4: _t->backgroundChanged(); break;
        case 5: _t->readMarkerLoadedChanged(); break;
        case 6: _t->parentIdsChanged(); break;
        case 7: _t->canonicalParentChanged(); break;
        case 8: _t->lastActiveTimeChanged(); break;
        case 9: _t->childrenNotificationCountChanged(); break;
        case 10: _t->childrenHaveHighlightNotificationsChanged(); break;
        case 11: _t->isInviteChanged(); break;
        case 12: _t->readOnlyChanged(); break;
        case 13: _t->displayNameChanged(); break;
        case 14: _t->pushNotificationStateChanged((*reinterpret_cast<std::add_pointer_t<PushNotificationState::State>>(_a[1]))); break;
        case 15: _t->canEncryptRoomChanged(); break;
        case 16: _t->historyVisibilityChanged(); break;
        case 17: _t->defaultUrlPreviewStateChanged(); break;
        case 18: _t->urlPreviewEnabledChanged(); break;
        case 19: _t->maxRoomVersionChanged(); break;
        case 20: _t->extraEventLoaded((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 21: _t->extraEventNotFound((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 22: _t->inviteTimestampChanged(); break;
        case 23: _t->pinnedMessageChanged(); break;
        case 24: _t->highlightCycleStartedChanged(); break;
        case 25: _t->spaceHasUnreadMessagesChanged(); break;
        case 26: _t->joinRuleStringChanged(); break;
        case 27: _t->showMessage((*reinterpret_cast<std::add_pointer_t<MessageType::Type>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 28: _t->updatePushNotificationState((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 29: _t->cacheLastEvent(); break;
        case 30: _t->invalidateLastUnreadHighlightId((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 31: _t->insertMemberSorted((*reinterpret_cast<std::add_pointer_t<Quotient::RoomMember>>(_a[1]))); break;
        case 32: _t->uploadFile((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<std::optional<Quotient::EventRelation>>>(_a[3]))); break;
        case 33: _t->uploadFile((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 34: _t->uploadFile((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 35: _t->acceptInvitation(); break;
        case 36: _t->forget(); break;
        case 37: _t->sendTypingNotification((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 38: _t->changeAvatar((*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[1]))); break;
        case 39: _t->toggleReaction((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 40: _t->deleteMessagesByUser((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 41: _t->sendLocation((*reinterpret_cast<std::add_pointer_t<float>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<float>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 42: _t->download((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QUrl>>(_a[2]))); break;
        case 43: _t->download((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 44: { bool _r = _t->downloadTempFile((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 45: { bool _r = _t->containsUser((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 46: { bool _r = _t->isUserBanned((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 47: { bool _r = _t->canSendEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 48: { bool _r = _t->canSendState((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 49: _t->reportEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 50: { QByteArray _r = _t->getEventJsonSource((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QByteArray*>(_a[0]) = std::move(_r); }  break;
        case 51: _t->openEventMediaExternally((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 52: _t->copyEventMedia((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 53: { bool _r = _t->hasParent();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 54: { QList<NeoChatRoom*> _r = _t->parentObjects((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QList<NeoChatRoom*>*>(_a[0]) = std::move(_r); }  break;
        case 55: { QList<NeoChatRoom*> _r = _t->parentObjects();
            if (_a[0]) *reinterpret_cast<QList<NeoChatRoom*>*>(_a[0]) = std::move(_r); }  break;
        case 56: { bool _r = _t->canModifyParent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 57: _t->addParent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 58: _t->addParent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 59: _t->addParent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 60: _t->removeParent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 61: _t->addChild((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[5]))); break;
        case 62: _t->addChild((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[4]))); break;
        case 63: _t->addChild((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[3]))); break;
        case 64: _t->addChild((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 65: _t->addChild((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 66: _t->removeChild((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<bool>>(_a[2]))); break;
        case 67: _t->removeChild((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 68: { bool _r = _t->isSuggested((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 69: _t->toggleChildSuggested((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 70: _t->mapAlias((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 71: _t->unmapAlias((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 72: _t->setCanonicalAlias((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 73: _t->setRoomState((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[3]))); break;
        case 74: _t->setUserPowerLevel((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 75: { ChatBarCache* _r = _t->cacheForType((*reinterpret_cast<std::add_pointer_t<ChatBarType::Type>>(_a[1])));
            if (_a[0]) *reinterpret_cast<ChatBarCache**>(_a[0]) = std::move(_r); }  break;
        case 76: _t->editLastMessage(); break;
        case 77: _t->postPoll((*reinterpret_cast<std::add_pointer_t<PollKind::Kind>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QList<QString>>>(_a[3]))); break;
        case 78: { QByteArray _r = _t->roomAcountDataJson((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QByteArray*>(_a[0]) = std::move(_r); }  break;
        case 79: { const Quotient::RoomEvent* _r = _t->findEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<const Quotient::RoomEvent**>(_a[0]) = std::move(_r); }  break;
        case 80: { NeochatRoomMember* _r = _t->qmlSafeMember((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<NeochatRoomMember**>(_a[0]) = std::move(_r); }  break;
        case 81: _t->pinEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 82: _t->unpinEvent((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 83: { bool _r = _t->isEventPinned((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 84: { bool _r = _t->eventIsThreaded((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 85: { QString _r = _t->rootIdForThread((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 86: { bool _r = _t->roomCreatorHasUltimatePowerLevel();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 87: { bool _r = _t->isCreator((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 88: _t->report((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 89: { QString _r = _t->findNextUnreadHighlightId();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 90: _t->markAllChildrenMessagesAsRead((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 91: _t->markAllMessagesAsRead((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 92: _t->markAllMessagesAsRead(); break;
        case 93: _t->setJoinRuleString((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QList<QString>>>(_a[2]))); break;
        case 94: _t->setJoinRuleString((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 95: { QString _r = _t->forwardMessage((*reinterpret_cast<std::add_pointer_t<NeoChatRoom*>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 95:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< NeoChatRoom* >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::cachedInputChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::busyChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::hasFileUploadingChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::fileUploadingProgressChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::backgroundChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::readMarkerLoadedChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::parentIdsChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::canonicalParentChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::lastActiveTimeChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::childrenNotificationCountChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::childrenHaveHighlightNotificationsChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::isInviteChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::readOnlyChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::displayNameChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)(PushNotificationState::State )>(_a, &NeoChatRoom::pushNotificationStateChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::canEncryptRoomChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::historyVisibilityChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::defaultUrlPreviewStateChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::urlPreviewEnabledChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::maxRoomVersionChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)(const QString & )>(_a, &NeoChatRoom::extraEventLoaded, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)(const QString & )>(_a, &NeoChatRoom::extraEventNotFound, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::inviteTimestampChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::pinnedMessageChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::highlightCycleStartedChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::spaceHasUnreadMessagesChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)()>(_a, &NeoChatRoom::joinRuleStringChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (NeoChatRoom::*)(MessageType::Type , const QString & )>(_a, &NeoChatRoom::showMessage, 27))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 5:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< NeochatRoomMember* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QDateTime*>(_v) = _t->lastActiveTime(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->hasFileUploading(); break;
        case 2: *reinterpret_cast<int*>(_v) = _t->fileUploadingProgress(); break;
        case 3: *reinterpret_cast<bool*>(_v) = _t->readMarkerLoaded(); break;
        case 4: *reinterpret_cast<QUrl*>(_v) = _t->avatarMediaUrl(); break;
        case 5: *reinterpret_cast<NeochatRoomMember**>(_v) = _t->directChatRemoteMember(); break;
        case 6: *reinterpret_cast<QList<QString>*>(_v) = _t->parentIds(); break;
        case 7: *reinterpret_cast<QString*>(_v) = _t->canonicalParent(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->isSpace(); break;
        case 9: *reinterpret_cast<qsizetype*>(_v) = _t->childrenNotificationCount(); break;
        case 10: *reinterpret_cast<bool*>(_v) = _t->childrenHaveHighlightNotifications(); break;
        case 11: *reinterpret_cast<bool*>(_v) = _t->isInvite(); break;
        case 12: *reinterpret_cast<bool*>(_v) = _t->readOnly(); break;
        case 13: *reinterpret_cast<int*>(_v) = _t->maxRoomVersion(); break;
        case 14: *reinterpret_cast<PushNotificationState::State*>(_v) = _t->pushNotificationState(); break;
        case 15: *reinterpret_cast<QString*>(_v) = _t->historyVisibility(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->defaultUrlPreviewState(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->urlPreviewEnabled(); break;
        case 18: *reinterpret_cast<bool*>(_v) = _t->canEncryptRoom(); break;
        case 19: *reinterpret_cast<ChatBarCache**>(_v) = _t->mainCache(); break;
        case 20: *reinterpret_cast<ChatBarCache**>(_v) = _t->editCache(); break;
        case 21: *reinterpret_cast<ChatBarCache**>(_v) = _t->threadCache(); break;
        case 22: *reinterpret_cast<QDateTime*>(_v) = _t->inviteTimestamp(); break;
        case 23: *reinterpret_cast<QString*>(_v) = _t->invitingUserId(); break;
        case 24: *reinterpret_cast<QString*>(_v) = _t->pinnedMessage(); break;
        case 25: *reinterpret_cast<bool*>(_v) = _t->highlightCycleStarted(); break;
        case 26: *reinterpret_cast<bool*>(_v) = _t->spaceHasUnreadMessages(); break;
        case 27: *reinterpret_cast<QString*>(_v) = _t->joinRuleString(); break;
        case 28: *reinterpret_cast<QList<QString>*>(_v) = _t->allowIds(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 1: _t->setHasFileUploading(*reinterpret_cast<bool*>(_v)); break;
        case 7: _t->setCanonicalParent(*reinterpret_cast<QString*>(_v)); break;
        case 14: _t->setPushNotificationState(*reinterpret_cast<PushNotificationState::State*>(_v)); break;
        case 15: _t->setHistoryVisibility(*reinterpret_cast<QString*>(_v)); break;
        case 16: _t->setDefaultUrlPreviewState(*reinterpret_cast<bool*>(_v)); break;
        case 17: _t->setUrlPreviewEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 27: _t->setJoinRuleString(*reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}

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

void *NeoChatRoom::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN11NeoChatRoomE_t>.strings))
        return static_cast<void*>(this);
    return Quotient::Room::qt_metacast(_clname);
}

int NeoChatRoom::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
    _id = Quotient::Room::qt_metacall(_c, _id, _a);
    if (_id < 0)
        return _id;
    if (_c == QMetaObject::InvokeMetaMethod) {
        if (_id < 96)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 96;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 96)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 96;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 29;
    }
    return _id;
}

// SIGNAL 0
void NeoChatRoom::cachedInputChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void NeoChatRoom::busyChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 1, nullptr);
}

// SIGNAL 2
void NeoChatRoom::hasFileUploadingChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void NeoChatRoom::fileUploadingProgressChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}

// SIGNAL 4
void NeoChatRoom::backgroundChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 4, nullptr);
}

// SIGNAL 5
void NeoChatRoom::readMarkerLoadedChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 5, nullptr);
}

// SIGNAL 6
void NeoChatRoom::parentIdsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 6, nullptr);
}

// SIGNAL 7
void NeoChatRoom::canonicalParentChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 7, nullptr);
}

// SIGNAL 8
void NeoChatRoom::lastActiveTimeChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 8, nullptr);
}

// SIGNAL 9
void NeoChatRoom::childrenNotificationCountChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}

// SIGNAL 10
void NeoChatRoom::childrenHaveHighlightNotificationsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 10, nullptr);
}

// SIGNAL 11
void NeoChatRoom::isInviteChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 11, nullptr);
}

// SIGNAL 12
void NeoChatRoom::readOnlyChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 12, nullptr);
}

// SIGNAL 13
void NeoChatRoom::displayNameChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 13, nullptr);
}

// SIGNAL 14
void NeoChatRoom::pushNotificationStateChanged(PushNotificationState::State _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

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

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

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

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

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

// SIGNAL 20
void NeoChatRoom::extraEventLoaded(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 20, nullptr, _t1);
}

// SIGNAL 21
void NeoChatRoom::extraEventNotFound(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 21, nullptr, _t1);
}

// SIGNAL 22
void NeoChatRoom::inviteTimestampChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 22, nullptr);
}

// SIGNAL 23
void NeoChatRoom::pinnedMessageChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 23, nullptr);
}

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

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

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

// SIGNAL 27
void NeoChatRoom::showMessage(MessageType::Type _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1, _t2);
}
namespace CheckNotifySignalValidity_ZN11NeoChatRoomE {
template<typename T> using has_nullary_avatarChanged = decltype(std::declval<T>().avatarChanged());
template<typename T> using has_unary_avatarChanged = decltype(std::declval<T>().avatarChanged(std::declval<QUrl>()));
static_assert(qxp::is_detected_v<has_nullary_avatarChanged, NeoChatRoom> || qxp::is_detected_v<has_unary_avatarChanged, NeoChatRoom>,
              "NOTIFY signal avatarChanged does not exist in class (or is private in its parent)");
template<typename T> using has_nullary_baseStateLoaded = decltype(std::declval<T>().baseStateLoaded());
template<typename T> using has_unary_baseStateLoaded = decltype(std::declval<T>().baseStateLoaded(std::declval<QDateTime>()));
static_assert(qxp::is_detected_v<has_nullary_baseStateLoaded, NeoChatRoom> || qxp::is_detected_v<has_unary_baseStateLoaded, NeoChatRoom>,
              "NOTIFY signal baseStateLoaded does not exist in class (or is private in its parent)");
}
QT_WARNING_POP
