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

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

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto AccountSettings::qt_create_metaobjectdata<qt_meta_tag_ZN15AccountSettingsE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "AccountSettings",
        "jidChanged",
        "",
        "passwordChanged",
        "hostChanged",
        "portChanged",
        "plainAuthAllowedChanged",
        "nameChanged",
        "enabledChanged",
        "inBandRegistrationFeaturesSupportedChanged",
        "httpUploadLimitChanged",
        "chatSupportAddressesChanged",
        "groupChatSupportAddressesChanged",
        "passwordVisibilityChanged",
        "encryptionChanged",
        "automaticMediaDownloadsRuleChanged",
        "contactNotificationRuleChanged",
        "groupChatNotificationRuleChanged",
        "geoLocationMapPreviewEnabledChanged",
        "geoLocationMapServiceChanged",
        "resetCustomConnectionSettings",
        "jid",
        "password",
        "host",
        "port",
        "autoDetectPort",
        "plainAuthAllowed",
        "name",
        "displayName",
        "enabled",
        "inBandRegistrationFeaturesSupported",
        "httpUploadLimit",
        "httpUploadLimitText",
        "chatSupportAddresses",
        "groupChatSupportAddresses",
        "passwordVisibility",
        "AccountSettings::PasswordVisibility",
        "encryption",
        "Encryption::Enum",
        "automaticMediaDownloadsRule",
        "AccountSettings::AutomaticMediaDownloadsRule",
        "contactNotificationRule",
        "AccountSettings::ContactNotificationRule",
        "groupChatNotificationRule",
        "AccountSettings::GroupChatNotificationRule",
        "geoLocationMapPreviewEnabled",
        "geoLocationMapService",
        "AccountSettings::GeoLocationMapService",
        "loginUriString",
        "PasswordVisibility",
        "Visible",
        "OnlyVisibleViaQrCode",
        "Invisible",
        "AutomaticMediaDownloadsRule",
        "Never",
        "PresenceOnly",
        "Always",
        "ContactNotificationRule",
        "GroupChatNotificationRule",
        "Mentioned",
        "GeoLocationMapService",
        "System",
        "InApp",
        "Web"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'jidChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'passwordChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'hostChanged'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'portChanged'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'plainAuthAllowedChanged'
        QtMocHelpers::SignalData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'nameChanged'
        QtMocHelpers::SignalData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'enabledChanged'
        QtMocHelpers::SignalData<void()>(8, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'inBandRegistrationFeaturesSupportedChanged'
        QtMocHelpers::SignalData<void()>(9, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'httpUploadLimitChanged'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'chatSupportAddressesChanged'
        QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'groupChatSupportAddressesChanged'
        QtMocHelpers::SignalData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'passwordVisibilityChanged'
        QtMocHelpers::SignalData<void()>(13, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'encryptionChanged'
        QtMocHelpers::SignalData<void()>(14, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'automaticMediaDownloadsRuleChanged'
        QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'contactNotificationRuleChanged'
        QtMocHelpers::SignalData<void()>(16, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'groupChatNotificationRuleChanged'
        QtMocHelpers::SignalData<void()>(17, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'geoLocationMapPreviewEnabledChanged'
        QtMocHelpers::SignalData<void()>(18, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'geoLocationMapServiceChanged'
        QtMocHelpers::SignalData<void()>(19, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'resetCustomConnectionSettings'
        QtMocHelpers::MethodData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'jid'
        QtMocHelpers::PropertyData<QString>(21, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 0),
        // property 'password'
        QtMocHelpers::PropertyData<QString>(22, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 1),
        // property 'host'
        QtMocHelpers::PropertyData<QString>(23, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 2),
        // property 'port'
        QtMocHelpers::PropertyData<quint16>(24, QMetaType::UShort, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 3),
        // property 'autoDetectPort'
        QtMocHelpers::PropertyData<quint16>(25, QMetaType::UShort, QMC::DefaultPropertyFlags | QMC::Constant | QMC::Final),
        // property 'plainAuthAllowed'
        QtMocHelpers::PropertyData<bool>(26, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 4),
        // property 'name'
        QtMocHelpers::PropertyData<QString>(27, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 5),
        // property 'displayName'
        QtMocHelpers::PropertyData<QString>(28, QMetaType::QString, QMC::DefaultPropertyFlags, 5),
        // property 'enabled'
        QtMocHelpers::PropertyData<bool>(29, QMetaType::Bool, QMC::DefaultPropertyFlags, 6),
        // property 'inBandRegistrationFeaturesSupported'
        QtMocHelpers::PropertyData<bool>(30, QMetaType::Bool, QMC::DefaultPropertyFlags, 7),
        // property 'httpUploadLimit'
        QtMocHelpers::PropertyData<qint64>(31, QMetaType::LongLong, QMC::DefaultPropertyFlags, 8),
        // property 'httpUploadLimitText'
        QtMocHelpers::PropertyData<QString>(32, QMetaType::QString, QMC::DefaultPropertyFlags, 8),
        // property 'chatSupportAddresses'
        QtMocHelpers::PropertyData<QList<QString>>(33, QMetaType::QStringList, QMC::DefaultPropertyFlags, 9),
        // property 'groupChatSupportAddresses'
        QtMocHelpers::PropertyData<QList<QString>>(34, QMetaType::QStringList, QMC::DefaultPropertyFlags, 10),
        // property 'passwordVisibility'
        QtMocHelpers::PropertyData<AccountSettings::PasswordVisibility>(35, 0x80000000 | 36, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 11),
        // property 'encryption'
        QtMocHelpers::PropertyData<Encryption::Enum>(37, 0x80000000 | 38, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 12),
        // property 'automaticMediaDownloadsRule'
        QtMocHelpers::PropertyData<AccountSettings::AutomaticMediaDownloadsRule>(39, 0x80000000 | 40, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 13),
        // property 'contactNotificationRule'
        QtMocHelpers::PropertyData<AccountSettings::ContactNotificationRule>(41, 0x80000000 | 42, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 14),
        // property 'groupChatNotificationRule'
        QtMocHelpers::PropertyData<AccountSettings::GroupChatNotificationRule>(43, 0x80000000 | 44, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 15),
        // property 'geoLocationMapPreviewEnabled'
        QtMocHelpers::PropertyData<bool>(45, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'geoLocationMapService'
        QtMocHelpers::PropertyData<AccountSettings::GeoLocationMapService>(46, 0x80000000 | 47, QMC::DefaultPropertyFlags | QMC::Writable | QMC::EnumOrFlag | QMC::StdCppSet, 17),
        // property 'loginUriString'
        QtMocHelpers::PropertyData<QString>(48, QMetaType::QString, QMC::DefaultPropertyFlags, 1),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'PasswordVisibility'
        QtMocHelpers::EnumData<enum PasswordVisibility>(49, 49, QMC::EnumIsScoped).add({
            {   50, PasswordVisibility::Visible },
            {   51, PasswordVisibility::OnlyVisibleViaQrCode },
            {   52, PasswordVisibility::Invisible },
        }),
        // enum 'AutomaticMediaDownloadsRule'
        QtMocHelpers::EnumData<enum AutomaticMediaDownloadsRule>(53, 53, QMC::EnumIsScoped).add({
            {   54, AutomaticMediaDownloadsRule::Never },
            {   55, AutomaticMediaDownloadsRule::PresenceOnly },
            {   56, AutomaticMediaDownloadsRule::Always },
        }),
        // enum 'ContactNotificationRule'
        QtMocHelpers::EnumData<enum ContactNotificationRule>(57, 57, QMC::EnumIsScoped).add({
            {   54, ContactNotificationRule::Never },
            {   55, ContactNotificationRule::PresenceOnly },
            {   56, ContactNotificationRule::Always },
        }),
        // enum 'GroupChatNotificationRule'
        QtMocHelpers::EnumData<enum GroupChatNotificationRule>(58, 58, QMC::EnumIsScoped).add({
            {   54, GroupChatNotificationRule::Never },
            {   59, GroupChatNotificationRule::Mentioned },
            {   56, GroupChatNotificationRule::Always },
        }),
        // enum 'GeoLocationMapService'
        QtMocHelpers::EnumData<enum GeoLocationMapService>(60, 60, QMC::EnumIsScoped).add({
            {   61, GeoLocationMapService::System },
            {   62, GeoLocationMapService::InApp },
            {   63, GeoLocationMapService::Web },
        }),
    };
    return QtMocHelpers::metaObjectData<AccountSettings, qt_meta_tag_ZN15AccountSettingsE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN15AccountSettingsE[] = {
    QMetaObject::SuperData::link<Encryption::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject AccountSettings::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15AccountSettingsE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN15AccountSettingsE_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN15AccountSettingsE,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN15AccountSettingsE_t>.metaTypes,
    nullptr
} };

void AccountSettings::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<AccountSettings *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->jidChanged(); break;
        case 1: _t->passwordChanged(); break;
        case 2: _t->hostChanged(); break;
        case 3: _t->portChanged(); break;
        case 4: _t->plainAuthAllowedChanged(); break;
        case 5: _t->nameChanged(); break;
        case 6: _t->enabledChanged(); break;
        case 7: _t->inBandRegistrationFeaturesSupportedChanged(); break;
        case 8: _t->httpUploadLimitChanged(); break;
        case 9: _t->chatSupportAddressesChanged(); break;
        case 10: _t->groupChatSupportAddressesChanged(); break;
        case 11: _t->passwordVisibilityChanged(); break;
        case 12: _t->encryptionChanged(); break;
        case 13: _t->automaticMediaDownloadsRuleChanged(); break;
        case 14: _t->contactNotificationRuleChanged(); break;
        case 15: _t->groupChatNotificationRuleChanged(); break;
        case 16: _t->geoLocationMapPreviewEnabledChanged(); break;
        case 17: _t->geoLocationMapServiceChanged(); break;
        case 18: _t->resetCustomConnectionSettings(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::jidChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::passwordChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::hostChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::portChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::plainAuthAllowedChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::nameChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::enabledChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::inBandRegistrationFeaturesSupportedChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::httpUploadLimitChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::chatSupportAddressesChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::groupChatSupportAddressesChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::passwordVisibilityChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::encryptionChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::automaticMediaDownloadsRuleChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::contactNotificationRuleChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::groupChatNotificationRuleChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::geoLocationMapPreviewEnabledChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (AccountSettings::*)()>(_a, &AccountSettings::geoLocationMapServiceChanged, 17))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 16:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< AccountSettings::AutomaticMediaDownloadsRule >(); break;
        case 17:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< AccountSettings::ContactNotificationRule >(); break;
        case 18:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< AccountSettings::GroupChatNotificationRule >(); break;
        case 14:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< AccountSettings::PasswordVisibility >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<QString*>(_v) = _t->jid(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->password(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->host(); break;
        case 3: *reinterpret_cast<quint16*>(_v) = _t->port(); break;
        case 4: *reinterpret_cast<quint16*>(_v) = _t->autoDetectPort(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->plainAuthAllowed(); break;
        case 6: *reinterpret_cast<QString*>(_v) = _t->name(); break;
        case 7: *reinterpret_cast<QString*>(_v) = _t->displayName(); break;
        case 8: *reinterpret_cast<bool*>(_v) = _t->enabled(); break;
        case 9: *reinterpret_cast<bool*>(_v) = _t->inBandRegistrationFeaturesSupported(); break;
        case 10: *reinterpret_cast<qint64*>(_v) = _t->httpUploadLimit(); break;
        case 11: *reinterpret_cast<QString*>(_v) = _t->httpUploadLimitText(); break;
        case 12: *reinterpret_cast<QList<QString>*>(_v) = _t->chatSupportAddresses(); break;
        case 13: *reinterpret_cast<QList<QString>*>(_v) = _t->groupChatSupportAddresses(); break;
        case 14: *reinterpret_cast<AccountSettings::PasswordVisibility*>(_v) = _t->passwordVisibility(); break;
        case 15: *reinterpret_cast<Encryption::Enum*>(_v) = _t->encryption(); break;
        case 16: *reinterpret_cast<AccountSettings::AutomaticMediaDownloadsRule*>(_v) = _t->automaticMediaDownloadsRule(); break;
        case 17: *reinterpret_cast<AccountSettings::ContactNotificationRule*>(_v) = _t->contactNotificationRule(); break;
        case 18: *reinterpret_cast<AccountSettings::GroupChatNotificationRule*>(_v) = _t->groupChatNotificationRule(); break;
        case 19: *reinterpret_cast<bool*>(_v) = _t->geoLocationMapPreviewEnabled(); break;
        case 20: *reinterpret_cast<AccountSettings::GeoLocationMapService*>(_v) = _t->geoLocationMapService(); break;
        case 21: *reinterpret_cast<QString*>(_v) = _t->loginUriString(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setJid(*reinterpret_cast<QString*>(_v)); break;
        case 1: _t->setPassword(*reinterpret_cast<QString*>(_v)); break;
        case 2: _t->setHost(*reinterpret_cast<QString*>(_v)); break;
        case 3: _t->setPort(*reinterpret_cast<quint16*>(_v)); break;
        case 5: _t->setPlainAuthAllowed(*reinterpret_cast<bool*>(_v)); break;
        case 6: _t->setName(*reinterpret_cast<QString*>(_v)); break;
        case 14: _t->setPasswordVisibility(*reinterpret_cast<AccountSettings::PasswordVisibility*>(_v)); break;
        case 15: _t->setEncryption(*reinterpret_cast<Encryption::Enum*>(_v)); break;
        case 16: _t->setAutomaticMediaDownloadsRule(*reinterpret_cast<AccountSettings::AutomaticMediaDownloadsRule*>(_v)); break;
        case 17: _t->setContactNotificationRule(*reinterpret_cast<AccountSettings::ContactNotificationRule*>(_v)); break;
        case 18: _t->setGroupChatNotificationRule(*reinterpret_cast<AccountSettings::GroupChatNotificationRule*>(_v)); break;
        case 19: _t->setGeoLocationMapPreviewEnabled(*reinterpret_cast<bool*>(_v)); break;
        case 20: _t->setGeoLocationMapService(*reinterpret_cast<AccountSettings::GeoLocationMapService*>(_v)); break;
        default: break;
        }
    }
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SIGNAL 17
void AccountSettings::geoLocationMapServiceChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 17, nullptr);
}
namespace {
struct qt_meta_tag_ZN10ConnectionE_t {};
} // unnamed namespace

template <> constexpr inline auto Connection::qt_create_metaobjectdata<qt_meta_tag_ZN10ConnectionE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Connection",
        "stateChanged",
        "",
        "connected",
        "disconnected",
        "errorChanged",
        "logIn",
        "logOut",
        "isApplicationBeingClosed",
        "state",
        "Enums::ConnectionState",
        "stateText",
        "error",
        "ClientController::ConnectionError",
        "errorText"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'stateChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'connected'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'disconnected'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'errorChanged'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'logIn'
        QtMocHelpers::MethodData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'logOut'
        QtMocHelpers::MethodData<void(bool)>(7, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 8 },
        }}),
        // Method 'logOut'
        QtMocHelpers::MethodData<void()>(7, 2, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'state'
        QtMocHelpers::PropertyData<Enums::ConnectionState>(9, 0x80000000 | 10, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 0),
        // property 'stateText'
        QtMocHelpers::PropertyData<QString>(11, QMetaType::QString, QMC::DefaultPropertyFlags, 0),
        // property 'error'
        QtMocHelpers::PropertyData<ClientController::ConnectionError>(12, 0x80000000 | 13, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 3),
        // property 'errorText'
        QtMocHelpers::PropertyData<QString>(14, QMetaType::QString, QMC::DefaultPropertyFlags, 3),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<Connection, qt_meta_tag_ZN10ConnectionE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT static const QMetaObject::SuperData qt_meta_extradata_ZN10ConnectionE[] = {
    QMetaObject::SuperData::link<Enums::staticMetaObject>(),
    QMetaObject::SuperData::link<ClientController::staticMetaObject>(),
    nullptr
};

Q_CONSTINIT const QMetaObject Connection::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10ConnectionE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10ConnectionE_t>.data,
    qt_static_metacall,
    qt_meta_extradata_ZN10ConnectionE,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN10ConnectionE_t>.metaTypes,
    nullptr
} };

void Connection::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Connection *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->stateChanged(); break;
        case 1: _t->connected(); break;
        case 2: _t->disconnected(); break;
        case 3: _t->errorChanged(); break;
        case 4: _t->logIn(); break;
        case 5: _t->logOut((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 6: _t->logOut(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::stateChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::connected, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::disconnected, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Connection::*)()>(_a, &Connection::errorChanged, 3))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<Enums::ConnectionState*>(_v) = _t->state(); break;
        case 1: *reinterpret_cast<QString*>(_v) = _t->stateText(); break;
        case 2: *reinterpret_cast<ClientController::ConnectionError*>(_v) = _t->error(); break;
        case 3: *reinterpret_cast<QString*>(_v) = _t->errorText(); break;
        default: break;
        }
    }
}

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

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

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

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

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

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

// SIGNAL 3
void Connection::errorChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 3, nullptr);
}
namespace {
struct qt_meta_tag_ZN7AccountE_t {};
} // unnamed namespace

template <> constexpr inline auto Account::qt_create_metaobjectdata<qt_meta_tag_ZN7AccountE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "Account",
        "enable",
        "",
        "disable",
        "logInWithUri",
        "LoginWithUriResult",
        "uriString",
        "openGeoLocation",
        "QGeoCoordinate",
        "geoCoordinate",
        "settings",
        "AccountSettings*",
        "connection",
        "Connection*",
        "atmController",
        "AtmController*",
        "blockingController",
        "BlockingController*",
        "callController",
        "CallController*",
        "encryptionController",
        "EncryptionController*",
        "fileSharingController",
        "FileSharingController*",
        "groupChatController",
        "GroupChatController*",
        "messageController",
        "MessageController*",
        "registrationController",
        "RegistrationController*",
        "rosterController",
        "RosterController*",
        "vCardController",
        "VCardController*",
        "versionController",
        "VersionController*",
        "avatarCache",
        "AvatarCache*",
        "presenceCache",
        "PresenceCache*",
        "Connecting",
        "PasswordNeeded",
        "InvalidLoginUri"
    };

    QtMocHelpers::UintData qt_methods {
        // Method 'enable'
        QtMocHelpers::MethodData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'disable'
        QtMocHelpers::MethodData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Method 'logInWithUri'
        QtMocHelpers::MethodData<enum LoginWithUriResult(const QString &)>(4, 2, QMC::AccessPublic, 0x80000000 | 5, {{
            { QMetaType::QString, 6 },
        }}),
        // Method 'openGeoLocation'
        QtMocHelpers::MethodData<bool(const QGeoCoordinate &)>(7, 2, QMC::AccessPublic, QMetaType::Bool, {{
            { 0x80000000 | 8, 9 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'settings'
        QtMocHelpers::PropertyData<AccountSettings*>(10, 0x80000000 | 11, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'connection'
        QtMocHelpers::PropertyData<Connection*>(12, 0x80000000 | 13, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'atmController'
        QtMocHelpers::PropertyData<AtmController*>(14, 0x80000000 | 15, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'blockingController'
        QtMocHelpers::PropertyData<BlockingController*>(16, 0x80000000 | 17, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'callController'
        QtMocHelpers::PropertyData<CallController*>(18, 0x80000000 | 19, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'encryptionController'
        QtMocHelpers::PropertyData<EncryptionController*>(20, 0x80000000 | 21, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'fileSharingController'
        QtMocHelpers::PropertyData<FileSharingController*>(22, 0x80000000 | 23, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'groupChatController'
        QtMocHelpers::PropertyData<GroupChatController*>(24, 0x80000000 | 25, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'messageController'
        QtMocHelpers::PropertyData<MessageController*>(26, 0x80000000 | 27, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'registrationController'
        QtMocHelpers::PropertyData<RegistrationController*>(28, 0x80000000 | 29, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'rosterController'
        QtMocHelpers::PropertyData<RosterController*>(30, 0x80000000 | 31, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'vCardController'
        QtMocHelpers::PropertyData<VCardController*>(32, 0x80000000 | 33, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'versionController'
        QtMocHelpers::PropertyData<VersionController*>(34, 0x80000000 | 35, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'avatarCache'
        QtMocHelpers::PropertyData<AvatarCache*>(36, 0x80000000 | 37, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
        // property 'presenceCache'
        QtMocHelpers::PropertyData<PresenceCache*>(38, 0x80000000 | 39, QMC::DefaultPropertyFlags | QMC::EnumOrFlag | QMC::Constant),
    };
    QtMocHelpers::UintData qt_enums {
        // enum 'LoginWithUriResult'
        QtMocHelpers::EnumData<enum LoginWithUriResult>(5, 5, QMC::EnumIsScoped).add({
            {   40, LoginWithUriResult::Connecting },
            {   41, LoginWithUriResult::PasswordNeeded },
            {   42, LoginWithUriResult::InvalidLoginUri },
        }),
    };
    return QtMocHelpers::metaObjectData<Account, qt_meta_tag_ZN7AccountE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject Account::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7AccountE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN7AccountE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN7AccountE_t>.metaTypes,
    nullptr
} };

void Account::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Account *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->enable(); break;
        case 1: _t->disable(); break;
        case 2: { enum LoginWithUriResult _r = _t->logInWithUri((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<enum LoginWithUriResult*>(_a[0]) = std::move(_r); }  break;
        case 3: { bool _r = _t->openGeoLocation((*reinterpret_cast<std::add_pointer_t<QGeoCoordinate>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 0:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< AccountSettings* >(); break;
        case 1:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< Connection* >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<AccountSettings**>(_v) = _t->m_settings; break;
        case 1: *reinterpret_cast<Connection**>(_v) = _t->m_connection; break;
        case 2: *reinterpret_cast<AtmController**>(_v) = _t->atmController(); break;
        case 3: *reinterpret_cast<BlockingController**>(_v) = _t->blockingController(); break;
        case 4: *reinterpret_cast<CallController**>(_v) = _t->callController(); break;
        case 5: *reinterpret_cast<EncryptionController**>(_v) = _t->encryptionController(); break;
        case 6: *reinterpret_cast<FileSharingController**>(_v) = _t->fileSharingController(); break;
        case 7: *reinterpret_cast<GroupChatController**>(_v) = _t->groupChatController(); break;
        case 8: *reinterpret_cast<MessageController**>(_v) = _t->messageController(); break;
        case 9: *reinterpret_cast<RegistrationController**>(_v) = _t->registrationController(); break;
        case 10: *reinterpret_cast<RosterController**>(_v) = _t->rosterController(); break;
        case 11: *reinterpret_cast<VCardController**>(_v) = _t->vCardController(); break;
        case 12: *reinterpret_cast<VersionController**>(_v) = _t->versionController(); break;
        case 13: *reinterpret_cast<AvatarCache**>(_v) = _t->avatarCache(); break;
        case 14: *reinterpret_cast<PresenceCache**>(_v) = _t->presenceCache(); break;
        default: break;
        }
    }
}

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

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

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