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

#include "../../../../cockatrice/src/settings/cache_settings.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 'cache_settings.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 69
#error "This file was generated using the moc from 6.9.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_ZN13SettingsCacheE_t {};
} // unnamed namespace

template <> constexpr inline auto SettingsCache::qt_create_metaobjectdata<qt_meta_tag_ZN13SettingsCacheE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "SettingsCache",
        "langChanged",
        "",
        "picsPathChanged",
        "cardDatabasePathChanged",
        "themeChanged",
        "picDownloadChanged",
        "displayCardNamesChanged",
        "overrideAllCardArtWithPersonalPreferenceChanged",
        "_overrideAllCardArtWithPersonalPreference",
        "bumpSetsWithCardsInDeckToTopChanged",
        "printingSelectorSortOrderChanged",
        "printingSelectorCardSizeChanged",
        "includeRebalancedCardsChanged",
        "_includeRebalancedCards",
        "printingSelectorNavigationButtonsVisibleChanged",
        "visualDeckStorageShowTagFilterChanged",
        "_visible",
        "visualDeckStorageShowBannerCardComboBoxChanged",
        "visualDeckStorageShowTagsOnDeckPreviewsChanged",
        "visualDeckStorageCardSizeChanged",
        "visualDeckStorageDrawUnusedColorIdentitiesChanged",
        "visualDeckStorageUnusedColorIdentitiesOpacityChanged",
        "value",
        "visualDeckStorageInGameChanged",
        "enabled",
        "horizontalHandChanged",
        "handJustificationChanged",
        "invertVerticalCoordinateChanged",
        "minPlayersForMultiColumnLayoutChanged",
        "soundEnabledChanged",
        "soundThemeChanged",
        "ignoreUnregisteredUsersChanged",
        "ignoreUnregisteredUserMessagesChanged",
        "pixmapCacheSizeChanged",
        "newSizeInMBs",
        "networkCacheSizeChanged",
        "redirectCacheTtlChanged",
        "newTtl",
        "masterVolumeChanged",
        "chatMentionCompleterChanged",
        "downloadSpoilerTimeIndexChanged",
        "downloadSpoilerStatusChanged",
        "useTearOffMenusChanged",
        "state",
        "roundCardCornersChanged",
        "roundCardCorners",
        "setDownloadSpoilerStatus",
        "_spoilerStatus",
        "setMainWindowGeometry",
        "_mainWindowGeometry",
        "setTokenDialogGeometry",
        "_tokenDialog",
        "setSetsDialogGeometry",
        "_setsDialog",
        "setLang",
        "_lang",
        "setShowTipsOnStartup",
        "_showTipsOnStartup",
        "setSeenTips",
        "QList<int>",
        "_seenTips",
        "setDeckPath",
        "_deckPath",
        "setReplaysPath",
        "_replaysPath",
        "setThemesPath",
        "_themesPath",
        "setCustomCardDatabasePath",
        "_customCardDatabasePath",
        "setPicsPath",
        "_picsPath",
        "setCardDatabasePath",
        "_cardDatabasePath",
        "setSpoilerDatabasePath",
        "_spoilerDatabasePath",
        "setTokenDatabasePath",
        "_tokenDatabasePath",
        "setThemeName",
        "_themeName",
        "setTabVisualDeckStorageOpen",
        "setTabServerOpen",
        "setTabAccountOpen",
        "setTabDeckStorageOpen",
        "setTabReplaysOpen",
        "setTabAdminOpen",
        "setTabLogOpen",
        "setChatMentionColor",
        "_chatMentionColor",
        "setChatHighlightColor",
        "_chatHighlightColor",
        "setPicDownload",
        "Qt::CheckState",
        "_picDownload",
        "setNotificationsEnabled",
        "_notificationsEnabled",
        "setSpectatorNotificationsEnabled",
        "_spectatorNotificationsEnabled",
        "setBuddyConnectNotificationsEnabled",
        "_buddyConnectNotificationsEnabled",
        "setDoubleClickToPlay",
        "_doubleClickToPlay",
        "setClickPlaysAllSelected",
        "_clickPlaysAllSelected",
        "setPlayToStack",
        "_playToStack",
        "setStartingHandSize",
        "_startingHandSize",
        "setAnnotateTokens",
        "_annotateTokens",
        "setTabGameSplitterSizes",
        "_tabGameSplitterSizes",
        "setShowShortcuts",
        "_showShortcuts",
        "setDisplayCardNames",
        "_displayCardNames",
        "setOverrideAllCardArtWithPersonalPreference",
        "_overrideAllCardArt",
        "setBumpSetsWithCardsInDeckToTop",
        "_bumpSetsWithCardsInDeckToTop",
        "setPrintingSelectorSortOrder",
        "_printingSelectorSortOrder",
        "setPrintingSelectorCardSize",
        "_printingSelectorCardSize",
        "setIncludeRebalancedCards",
        "setPrintingSelectorNavigationButtonsVisible",
        "_navigationButtonsVisible",
        "setVisualDeckStorageSortingOrder",
        "_visualDeckStorageSortingOrder",
        "setVisualDeckStorageShowFolders",
        "setVisualDeckStorageShowTagFilter",
        "_showTags",
        "setVisualDeckStorageSearchFolderNames",
        "setVisualDeckStorageShowBannerCardComboBox",
        "_showBannerCardComboBox",
        "setVisualDeckStorageShowTagsOnDeckPreviews",
        "setVisualDeckStorageCardSize",
        "_visualDeckStorageCardSize",
        "setVisualDeckStorageDrawUnusedColorIdentities",
        "_visualDeckStorageDrawUnusedColorIdentities",
        "setVisualDeckStorageUnusedColorIdentitiesOpacity",
        "_visualDeckStorageUnusedColorIdentitiesOpacity",
        "setVisualDeckStoragePromptForConversion",
        "_visualDeckStoragePromptForConversion",
        "setVisualDeckStorageAlwaysConvert",
        "_visualDeckStorageAlwaysConvert",
        "setVisualDeckStorageInGame",
        "setHorizontalHand",
        "_horizontalHand",
        "setInvertVerticalCoordinate",
        "_invertVerticalCoordinate",
        "setMinPlayersForMultiColumnLayout",
        "_minPlayersForMultiColumnLayout",
        "setTapAnimation",
        "_tapAnimation",
        "setAutoRotateSidewaysLayoutCards",
        "_autoRotateSidewaysLayoutCards",
        "setOpenDeckInNewTab",
        "_openDeckInNewTab",
        "setRewindBufferingMs",
        "_rewindBufferingMs",
        "setChatMention",
        "_chatMention",
        "setChatMentionCompleter",
        "_chatMentionCompleter",
        "setChatMentionForeground",
        "_chatMentionForeground",
        "setChatHighlightForeground",
        "_chatHighlightForeground",
        "setZoneViewGroupByIndex",
        "_zoneViewGroupByIndex",
        "setZoneViewSortByIndex",
        "_zoneViewSortByIndex",
        "setZoneViewPileView",
        "_zoneViewPileView",
        "setSoundEnabled",
        "_soundEnabled",
        "setSoundThemeName",
        "_soundThemeName",
        "setIgnoreUnregisteredUsers",
        "_ignoreUnregisteredUsers",
        "setIgnoreUnregisteredUserMessages",
        "_ignoreUnregisteredUserMessages",
        "setPixmapCacheSize",
        "_pixmapCacheSize",
        "setNetworkCacheSizeInMB",
        "_networkCacheSize",
        "setNetworkRedirectCacheTtl",
        "_redirectCacheTtl",
        "setCardScaling",
        "_scaleCards",
        "setStackCardOverlapPercent",
        "_verticalCardOverlapPercent",
        "setShowMessagePopups",
        "_showMessagePopups",
        "setShowMentionPopups",
        "_showMentionPopups",
        "setRoomHistory",
        "_roomHistory",
        "setLeftJustified",
        "_leftJustified",
        "setMasterVolume",
        "_masterVolume",
        "setCardInfoViewMode",
        "_viewMode",
        "setHighlightWords",
        "_highlightWords",
        "setGameDescription",
        "_gameDescription",
        "setMaxPlayers",
        "_maxPlayers",
        "setGameTypes",
        "_gameTypes",
        "setOnlyBuddies",
        "_onlyBuddies",
        "setOnlyRegistered",
        "_onlyRegistered",
        "setSpectatorsAllowed",
        "_spectatorsAllowed",
        "setSpectatorsNeedPassword",
        "_spectatorsNeedPassword",
        "setSpectatorsCanTalk",
        "_spectatorsCanTalk",
        "setSpectatorsCanSeeEverything",
        "_spectatorsCanSeeEverything",
        "setCreateGameAsSpectator",
        "_createGameAsSpectator",
        "setDefaultStartingLifeTotal",
        "_defaultStartingLifeTotal",
        "setRememberGameSettings",
        "_rememberGameSettings",
        "setCheckUpdatesOnStartup",
        "setNotifyAboutUpdate",
        "_notifyaboutupdate",
        "setNotifyAboutNewVersion",
        "_notifyaboutnewversion",
        "setUpdateReleaseChannelIndex",
        "setMaxFontSize",
        "_max",
        "setRoundCardCorners",
        "_roundCardCorners"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'langChanged'
        QtMocHelpers::SignalData<void()>(1, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'picsPathChanged'
        QtMocHelpers::SignalData<void()>(3, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'cardDatabasePathChanged'
        QtMocHelpers::SignalData<void()>(4, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'themeChanged'
        QtMocHelpers::SignalData<void()>(5, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'picDownloadChanged'
        QtMocHelpers::SignalData<void()>(6, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'displayCardNamesChanged'
        QtMocHelpers::SignalData<void()>(7, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'overrideAllCardArtWithPersonalPreferenceChanged'
        QtMocHelpers::SignalData<void(bool)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 9 },
        }}),
        // Signal 'bumpSetsWithCardsInDeckToTopChanged'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'printingSelectorSortOrderChanged'
        QtMocHelpers::SignalData<void()>(11, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'printingSelectorCardSizeChanged'
        QtMocHelpers::SignalData<void()>(12, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'includeRebalancedCardsChanged'
        QtMocHelpers::SignalData<void(bool)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 14 },
        }}),
        // Signal 'printingSelectorNavigationButtonsVisibleChanged'
        QtMocHelpers::SignalData<void()>(15, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'visualDeckStorageShowTagFilterChanged'
        QtMocHelpers::SignalData<void(bool)>(16, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'visualDeckStorageShowBannerCardComboBoxChanged'
        QtMocHelpers::SignalData<void(bool)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'visualDeckStorageShowTagsOnDeckPreviewsChanged'
        QtMocHelpers::SignalData<void(bool)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'visualDeckStorageCardSizeChanged'
        QtMocHelpers::SignalData<void()>(20, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'visualDeckStorageDrawUnusedColorIdentitiesChanged'
        QtMocHelpers::SignalData<void(bool)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 17 },
        }}),
        // Signal 'visualDeckStorageUnusedColorIdentitiesOpacityChanged'
        QtMocHelpers::SignalData<void(bool)>(22, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 23 },
        }}),
        // Signal 'visualDeckStorageInGameChanged'
        QtMocHelpers::SignalData<void(bool)>(24, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 25 },
        }}),
        // Signal 'horizontalHandChanged'
        QtMocHelpers::SignalData<void()>(26, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'handJustificationChanged'
        QtMocHelpers::SignalData<void()>(27, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'invertVerticalCoordinateChanged'
        QtMocHelpers::SignalData<void()>(28, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'minPlayersForMultiColumnLayoutChanged'
        QtMocHelpers::SignalData<void()>(29, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'soundEnabledChanged'
        QtMocHelpers::SignalData<void()>(30, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'soundThemeChanged'
        QtMocHelpers::SignalData<void()>(31, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'ignoreUnregisteredUsersChanged'
        QtMocHelpers::SignalData<void()>(32, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'ignoreUnregisteredUserMessagesChanged'
        QtMocHelpers::SignalData<void()>(33, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'pixmapCacheSizeChanged'
        QtMocHelpers::SignalData<void(int)>(34, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 35 },
        }}),
        // Signal 'networkCacheSizeChanged'
        QtMocHelpers::SignalData<void(int)>(36, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 35 },
        }}),
        // Signal 'redirectCacheTtlChanged'
        QtMocHelpers::SignalData<void(int)>(37, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 38 },
        }}),
        // Signal 'masterVolumeChanged'
        QtMocHelpers::SignalData<void(int)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 23 },
        }}),
        // Signal 'chatMentionCompleterChanged'
        QtMocHelpers::SignalData<void()>(40, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'downloadSpoilerTimeIndexChanged'
        QtMocHelpers::SignalData<void()>(41, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'downloadSpoilerStatusChanged'
        QtMocHelpers::SignalData<void()>(42, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'useTearOffMenusChanged'
        QtMocHelpers::SignalData<void(bool)>(43, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 44 },
        }}),
        // Signal 'roundCardCornersChanged'
        QtMocHelpers::SignalData<void(bool)>(45, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 46 },
        }}),
        // Slot 'setDownloadSpoilerStatus'
        QtMocHelpers::SlotData<void(bool)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 48 },
        }}),
        // Slot 'setMainWindowGeometry'
        QtMocHelpers::SlotData<void(const QByteArray &)>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 50 },
        }}),
        // Slot 'setTokenDialogGeometry'
        QtMocHelpers::SlotData<void(const QByteArray &)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 52 },
        }}),
        // Slot 'setSetsDialogGeometry'
        QtMocHelpers::SlotData<void(const QByteArray &)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 54 },
        }}),
        // Slot 'setLang'
        QtMocHelpers::SlotData<void(const QString &)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 56 },
        }}),
        // Slot 'setShowTipsOnStartup'
        QtMocHelpers::SlotData<void(bool)>(57, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 58 },
        }}),
        // Slot 'setSeenTips'
        QtMocHelpers::SlotData<void(const QList<int> &)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 60, 61 },
        }}),
        // Slot 'setDeckPath'
        QtMocHelpers::SlotData<void(const QString &)>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 63 },
        }}),
        // Slot 'setReplaysPath'
        QtMocHelpers::SlotData<void(const QString &)>(64, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 65 },
        }}),
        // Slot 'setThemesPath'
        QtMocHelpers::SlotData<void(const QString &)>(66, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 67 },
        }}),
        // Slot 'setCustomCardDatabasePath'
        QtMocHelpers::SlotData<void(const QString &)>(68, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 69 },
        }}),
        // Slot 'setPicsPath'
        QtMocHelpers::SlotData<void(const QString &)>(70, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 71 },
        }}),
        // Slot 'setCardDatabasePath'
        QtMocHelpers::SlotData<void(const QString &)>(72, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 73 },
        }}),
        // Slot 'setSpoilerDatabasePath'
        QtMocHelpers::SlotData<void(const QString &)>(74, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 75 },
        }}),
        // Slot 'setTokenDatabasePath'
        QtMocHelpers::SlotData<void(const QString &)>(76, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 77 },
        }}),
        // Slot 'setThemeName'
        QtMocHelpers::SlotData<void(const QString &)>(78, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 79 },
        }}),
        // Slot 'setTabVisualDeckStorageOpen'
        QtMocHelpers::SlotData<void(bool)>(80, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 23 },
        }}),
        // Slot 'setTabServerOpen'
        QtMocHelpers::SlotData<void(bool)>(81, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 23 },
        }}),
        // Slot 'setTabAccountOpen'
        QtMocHelpers::SlotData<void(bool)>(82, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 23 },
        }}),
        // Slot 'setTabDeckStorageOpen'
        QtMocHelpers::SlotData<void(bool)>(83, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 23 },
        }}),
        // Slot 'setTabReplaysOpen'
        QtMocHelpers::SlotData<void(bool)>(84, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 23 },
        }}),
        // Slot 'setTabAdminOpen'
        QtMocHelpers::SlotData<void(bool)>(85, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 23 },
        }}),
        // Slot 'setTabLogOpen'
        QtMocHelpers::SlotData<void(bool)>(86, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 23 },
        }}),
        // Slot 'setChatMentionColor'
        QtMocHelpers::SlotData<void(const QString &)>(87, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 88 },
        }}),
        // Slot 'setChatHighlightColor'
        QtMocHelpers::SlotData<void(const QString &)>(89, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 90 },
        }}),
        // Slot 'setPicDownload'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(91, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 93 },
        }}),
        // Slot 'setNotificationsEnabled'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(94, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 95 },
        }}),
        // Slot 'setSpectatorNotificationsEnabled'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 97 },
        }}),
        // Slot 'setBuddyConnectNotificationsEnabled'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(98, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 99 },
        }}),
        // Slot 'setDoubleClickToPlay'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(100, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 101 },
        }}),
        // Slot 'setClickPlaysAllSelected'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(102, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 103 },
        }}),
        // Slot 'setPlayToStack'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(104, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 105 },
        }}),
        // Slot 'setStartingHandSize'
        QtMocHelpers::SlotData<void(int)>(106, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 107 },
        }}),
        // Slot 'setAnnotateTokens'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(108, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 109 },
        }}),
        // Slot 'setTabGameSplitterSizes'
        QtMocHelpers::SlotData<void(const QByteArray &)>(110, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 111 },
        }}),
        // Slot 'setShowShortcuts'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(112, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 113 },
        }}),
        // Slot 'setDisplayCardNames'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(114, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 115 },
        }}),
        // Slot 'setOverrideAllCardArtWithPersonalPreference'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(116, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 117 },
        }}),
        // Slot 'setBumpSetsWithCardsInDeckToTop'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(118, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 119 },
        }}),
        // Slot 'setPrintingSelectorSortOrder'
        QtMocHelpers::SlotData<void(int)>(120, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 121 },
        }}),
        // Slot 'setPrintingSelectorCardSize'
        QtMocHelpers::SlotData<void(int)>(122, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 123 },
        }}),
        // Slot 'setIncludeRebalancedCards'
        QtMocHelpers::SlotData<void(bool)>(124, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 14 },
        }}),
        // Slot 'setPrintingSelectorNavigationButtonsVisible'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(125, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 126 },
        }}),
        // Slot 'setVisualDeckStorageSortingOrder'
        QtMocHelpers::SlotData<void(int)>(127, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 128 },
        }}),
        // Slot 'setVisualDeckStorageShowFolders'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(129, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 23 },
        }}),
        // Slot 'setVisualDeckStorageShowTagFilter'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(130, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 131 },
        }}),
        // Slot 'setVisualDeckStorageSearchFolderNames'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(132, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 23 },
        }}),
        // Slot 'setVisualDeckStorageShowBannerCardComboBox'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(133, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 134 },
        }}),
        // Slot 'setVisualDeckStorageShowTagsOnDeckPreviews'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(135, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 131 },
        }}),
        // Slot 'setVisualDeckStorageCardSize'
        QtMocHelpers::SlotData<void(int)>(136, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 137 },
        }}),
        // Slot 'setVisualDeckStorageDrawUnusedColorIdentities'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(138, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 139 },
        }}),
        // Slot 'setVisualDeckStorageUnusedColorIdentitiesOpacity'
        QtMocHelpers::SlotData<void(int)>(140, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 141 },
        }}),
        // Slot 'setVisualDeckStoragePromptForConversion'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(142, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 143 },
        }}),
        // Slot 'setVisualDeckStorageAlwaysConvert'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(144, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 145 },
        }}),
        // Slot 'setVisualDeckStorageInGame'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(146, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 23 },
        }}),
        // Slot 'setHorizontalHand'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(147, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 148 },
        }}),
        // Slot 'setInvertVerticalCoordinate'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(149, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 150 },
        }}),
        // Slot 'setMinPlayersForMultiColumnLayout'
        QtMocHelpers::SlotData<void(int)>(151, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 152 },
        }}),
        // Slot 'setTapAnimation'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(153, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 154 },
        }}),
        // Slot 'setAutoRotateSidewaysLayoutCards'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(155, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 156 },
        }}),
        // Slot 'setOpenDeckInNewTab'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(157, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 158 },
        }}),
        // Slot 'setRewindBufferingMs'
        QtMocHelpers::SlotData<void(int)>(159, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 160 },
        }}),
        // Slot 'setChatMention'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(161, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 162 },
        }}),
        // Slot 'setChatMentionCompleter'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(163, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 164 },
        }}),
        // Slot 'setChatMentionForeground'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(165, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 166 },
        }}),
        // Slot 'setChatHighlightForeground'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(167, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 168 },
        }}),
        // Slot 'setZoneViewGroupByIndex'
        QtMocHelpers::SlotData<void(const int)>(169, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 170 },
        }}),
        // Slot 'setZoneViewSortByIndex'
        QtMocHelpers::SlotData<void(const int)>(171, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 172 },
        }}),
        // Slot 'setZoneViewPileView'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(173, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 174 },
        }}),
        // Slot 'setSoundEnabled'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(175, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 176 },
        }}),
        // Slot 'setSoundThemeName'
        QtMocHelpers::SlotData<void(const QString &)>(177, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 178 },
        }}),
        // Slot 'setIgnoreUnregisteredUsers'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(179, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 180 },
        }}),
        // Slot 'setIgnoreUnregisteredUserMessages'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(181, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 182 },
        }}),
        // Slot 'setPixmapCacheSize'
        QtMocHelpers::SlotData<void(const int)>(183, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 184 },
        }}),
        // Slot 'setNetworkCacheSizeInMB'
        QtMocHelpers::SlotData<void(const int)>(185, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 186 },
        }}),
        // Slot 'setNetworkRedirectCacheTtl'
        QtMocHelpers::SlotData<void(const int)>(187, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 188 },
        }}),
        // Slot 'setCardScaling'
        QtMocHelpers::SlotData<void(const Qt::CheckState)>(189, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 190 },
        }}),
        // Slot 'setStackCardOverlapPercent'
        QtMocHelpers::SlotData<void(const int)>(191, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 192 },
        }}),
        // Slot 'setShowMessagePopups'
        QtMocHelpers::SlotData<void(const Qt::CheckState)>(193, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 194 },
        }}),
        // Slot 'setShowMentionPopups'
        QtMocHelpers::SlotData<void(const Qt::CheckState)>(195, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 196 },
        }}),
        // Slot 'setRoomHistory'
        QtMocHelpers::SlotData<void(const Qt::CheckState)>(197, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 198 },
        }}),
        // Slot 'setLeftJustified'
        QtMocHelpers::SlotData<void(const Qt::CheckState)>(199, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 200 },
        }}),
        // Slot 'setMasterVolume'
        QtMocHelpers::SlotData<void(const int)>(201, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 202 },
        }}),
        // Slot 'setCardInfoViewMode'
        QtMocHelpers::SlotData<void(const int)>(203, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 204 },
        }}),
        // Slot 'setHighlightWords'
        QtMocHelpers::SlotData<void(const QString &)>(205, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 206 },
        }}),
        // Slot 'setGameDescription'
        QtMocHelpers::SlotData<void(const QString)>(207, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 208 },
        }}),
        // Slot 'setMaxPlayers'
        QtMocHelpers::SlotData<void(const int)>(209, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 210 },
        }}),
        // Slot 'setGameTypes'
        QtMocHelpers::SlotData<void(const QString)>(211, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 212 },
        }}),
        // Slot 'setOnlyBuddies'
        QtMocHelpers::SlotData<void(const bool)>(213, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 214 },
        }}),
        // Slot 'setOnlyRegistered'
        QtMocHelpers::SlotData<void(const bool)>(215, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 216 },
        }}),
        // Slot 'setSpectatorsAllowed'
        QtMocHelpers::SlotData<void(const bool)>(217, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 218 },
        }}),
        // Slot 'setSpectatorsNeedPassword'
        QtMocHelpers::SlotData<void(const bool)>(219, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 220 },
        }}),
        // Slot 'setSpectatorsCanTalk'
        QtMocHelpers::SlotData<void(const bool)>(221, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 222 },
        }}),
        // Slot 'setSpectatorsCanSeeEverything'
        QtMocHelpers::SlotData<void(const bool)>(223, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 224 },
        }}),
        // Slot 'setCreateGameAsSpectator'
        QtMocHelpers::SlotData<void(const bool)>(225, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 226 },
        }}),
        // Slot 'setDefaultStartingLifeTotal'
        QtMocHelpers::SlotData<void(const int)>(227, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 228 },
        }}),
        // Slot 'setRememberGameSettings'
        QtMocHelpers::SlotData<void(const bool)>(229, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 230 },
        }}),
        // Slot 'setCheckUpdatesOnStartup'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(231, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 23 },
        }}),
        // Slot 'setNotifyAboutUpdate'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(232, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 233 },
        }}),
        // Slot 'setNotifyAboutNewVersion'
        QtMocHelpers::SlotData<void(Qt::CheckState)>(234, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 92, 235 },
        }}),
        // Slot 'setUpdateReleaseChannelIndex'
        QtMocHelpers::SlotData<void(int)>(236, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 23 },
        }}),
        // Slot 'setMaxFontSize'
        QtMocHelpers::SlotData<void(int)>(237, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 238 },
        }}),
        // Slot 'setRoundCardCorners'
        QtMocHelpers::SlotData<void(bool)>(239, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 240 },
        }}),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<SettingsCache, qt_meta_tag_ZN13SettingsCacheE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject SettingsCache::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13SettingsCacheE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13SettingsCacheE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13SettingsCacheE_t>.metaTypes,
    nullptr
} };

void SettingsCache::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<SettingsCache *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->langChanged(); break;
        case 1: _t->picsPathChanged(); break;
        case 2: _t->cardDatabasePathChanged(); break;
        case 3: _t->themeChanged(); break;
        case 4: _t->picDownloadChanged(); break;
        case 5: _t->displayCardNamesChanged(); break;
        case 6: _t->overrideAllCardArtWithPersonalPreferenceChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->bumpSetsWithCardsInDeckToTopChanged(); break;
        case 8: _t->printingSelectorSortOrderChanged(); break;
        case 9: _t->printingSelectorCardSizeChanged(); break;
        case 10: _t->includeRebalancedCardsChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 11: _t->printingSelectorNavigationButtonsVisibleChanged(); break;
        case 12: _t->visualDeckStorageShowTagFilterChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 13: _t->visualDeckStorageShowBannerCardComboBoxChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 14: _t->visualDeckStorageShowTagsOnDeckPreviewsChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 15: _t->visualDeckStorageCardSizeChanged(); break;
        case 16: _t->visualDeckStorageDrawUnusedColorIdentitiesChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 17: _t->visualDeckStorageUnusedColorIdentitiesOpacityChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->visualDeckStorageInGameChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 19: _t->horizontalHandChanged(); break;
        case 20: _t->handJustificationChanged(); break;
        case 21: _t->invertVerticalCoordinateChanged(); break;
        case 22: _t->minPlayersForMultiColumnLayoutChanged(); break;
        case 23: _t->soundEnabledChanged(); break;
        case 24: _t->soundThemeChanged(); break;
        case 25: _t->ignoreUnregisteredUsersChanged(); break;
        case 26: _t->ignoreUnregisteredUserMessagesChanged(); break;
        case 27: _t->pixmapCacheSizeChanged((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 28: _t->networkCacheSizeChanged((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 29: _t->redirectCacheTtlChanged((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 30: _t->masterVolumeChanged((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 31: _t->chatMentionCompleterChanged(); break;
        case 32: _t->downloadSpoilerTimeIndexChanged(); break;
        case 33: _t->downloadSpoilerStatusChanged(); break;
        case 34: _t->useTearOffMenusChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 35: _t->roundCardCornersChanged((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 36: _t->setDownloadSpoilerStatus((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 37: _t->setMainWindowGeometry((*reinterpret_cast< std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 38: _t->setTokenDialogGeometry((*reinterpret_cast< std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 39: _t->setSetsDialogGeometry((*reinterpret_cast< std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 40: _t->setLang((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 41: _t->setShowTipsOnStartup((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 42: _t->setSeenTips((*reinterpret_cast< std::add_pointer_t<QList<int>>>(_a[1]))); break;
        case 43: _t->setDeckPath((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 44: _t->setReplaysPath((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 45: _t->setThemesPath((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 46: _t->setCustomCardDatabasePath((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 47: _t->setPicsPath((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 48: _t->setCardDatabasePath((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 49: _t->setSpoilerDatabasePath((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 50: _t->setTokenDatabasePath((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 51: _t->setThemeName((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 52: _t->setTabVisualDeckStorageOpen((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 53: _t->setTabServerOpen((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 54: _t->setTabAccountOpen((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 55: _t->setTabDeckStorageOpen((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 56: _t->setTabReplaysOpen((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 57: _t->setTabAdminOpen((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 58: _t->setTabLogOpen((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 59: _t->setChatMentionColor((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 60: _t->setChatHighlightColor((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 61: _t->setPicDownload((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 62: _t->setNotificationsEnabled((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 63: _t->setSpectatorNotificationsEnabled((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 64: _t->setBuddyConnectNotificationsEnabled((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 65: _t->setDoubleClickToPlay((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 66: _t->setClickPlaysAllSelected((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 67: _t->setPlayToStack((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 68: _t->setStartingHandSize((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 69: _t->setAnnotateTokens((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 70: _t->setTabGameSplitterSizes((*reinterpret_cast< std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 71: _t->setShowShortcuts((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 72: _t->setDisplayCardNames((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 73: _t->setOverrideAllCardArtWithPersonalPreference((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 74: _t->setBumpSetsWithCardsInDeckToTop((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 75: _t->setPrintingSelectorSortOrder((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 76: _t->setPrintingSelectorCardSize((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 77: _t->setIncludeRebalancedCards((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 78: _t->setPrintingSelectorNavigationButtonsVisible((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 79: _t->setVisualDeckStorageSortingOrder((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 80: _t->setVisualDeckStorageShowFolders((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 81: _t->setVisualDeckStorageShowTagFilter((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 82: _t->setVisualDeckStorageSearchFolderNames((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 83: _t->setVisualDeckStorageShowBannerCardComboBox((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 84: _t->setVisualDeckStorageShowTagsOnDeckPreviews((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 85: _t->setVisualDeckStorageCardSize((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 86: _t->setVisualDeckStorageDrawUnusedColorIdentities((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 87: _t->setVisualDeckStorageUnusedColorIdentitiesOpacity((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 88: _t->setVisualDeckStoragePromptForConversion((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 89: _t->setVisualDeckStorageAlwaysConvert((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 90: _t->setVisualDeckStorageInGame((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 91: _t->setHorizontalHand((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 92: _t->setInvertVerticalCoordinate((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 93: _t->setMinPlayersForMultiColumnLayout((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 94: _t->setTapAnimation((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 95: _t->setAutoRotateSidewaysLayoutCards((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 96: _t->setOpenDeckInNewTab((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 97: _t->setRewindBufferingMs((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 98: _t->setChatMention((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 99: _t->setChatMentionCompleter((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 100: _t->setChatMentionForeground((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 101: _t->setChatHighlightForeground((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 102: _t->setZoneViewGroupByIndex((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 103: _t->setZoneViewSortByIndex((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 104: _t->setZoneViewPileView((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 105: _t->setSoundEnabled((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 106: _t->setSoundThemeName((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 107: _t->setIgnoreUnregisteredUsers((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 108: _t->setIgnoreUnregisteredUserMessages((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 109: _t->setPixmapCacheSize((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 110: _t->setNetworkCacheSizeInMB((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 111: _t->setNetworkRedirectCacheTtl((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 112: _t->setCardScaling((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 113: _t->setStackCardOverlapPercent((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 114: _t->setShowMessagePopups((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 115: _t->setShowMentionPopups((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 116: _t->setRoomHistory((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 117: _t->setLeftJustified((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 118: _t->setMasterVolume((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 119: _t->setCardInfoViewMode((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 120: _t->setHighlightWords((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 121: _t->setGameDescription((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 122: _t->setMaxPlayers((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 123: _t->setGameTypes((*reinterpret_cast< std::add_pointer_t<QString>>(_a[1]))); break;
        case 124: _t->setOnlyBuddies((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 125: _t->setOnlyRegistered((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 126: _t->setSpectatorsAllowed((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 127: _t->setSpectatorsNeedPassword((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 128: _t->setSpectatorsCanTalk((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 129: _t->setSpectatorsCanSeeEverything((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 130: _t->setCreateGameAsSpectator((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 131: _t->setDefaultStartingLifeTotal((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 132: _t->setRememberGameSettings((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        case 133: _t->setCheckUpdatesOnStartup((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 134: _t->setNotifyAboutUpdate((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 135: _t->setNotifyAboutNewVersion((*reinterpret_cast< std::add_pointer_t<Qt::CheckState>>(_a[1]))); break;
        case 136: _t->setUpdateReleaseChannelIndex((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 137: _t->setMaxFontSize((*reinterpret_cast< std::add_pointer_t<int>>(_a[1]))); break;
        case 138: _t->setRoundCardCorners((*reinterpret_cast< std::add_pointer_t<bool>>(_a[1]))); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 42:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QList<int> >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::langChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::picsPathChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::cardDatabasePathChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::themeChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::picDownloadChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::displayCardNamesChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(bool )>(_a, &SettingsCache::overrideAllCardArtWithPersonalPreferenceChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::bumpSetsWithCardsInDeckToTopChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::printingSelectorSortOrderChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::printingSelectorCardSizeChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(bool )>(_a, &SettingsCache::includeRebalancedCardsChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::printingSelectorNavigationButtonsVisibleChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(bool )>(_a, &SettingsCache::visualDeckStorageShowTagFilterChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(bool )>(_a, &SettingsCache::visualDeckStorageShowBannerCardComboBoxChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(bool )>(_a, &SettingsCache::visualDeckStorageShowTagsOnDeckPreviewsChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::visualDeckStorageCardSizeChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(bool )>(_a, &SettingsCache::visualDeckStorageDrawUnusedColorIdentitiesChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(bool )>(_a, &SettingsCache::visualDeckStorageUnusedColorIdentitiesOpacityChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(bool )>(_a, &SettingsCache::visualDeckStorageInGameChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::horizontalHandChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::handJustificationChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::invertVerticalCoordinateChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::minPlayersForMultiColumnLayoutChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::soundEnabledChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::soundThemeChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::ignoreUnregisteredUsersChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::ignoreUnregisteredUserMessagesChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(int )>(_a, &SettingsCache::pixmapCacheSizeChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(int )>(_a, &SettingsCache::networkCacheSizeChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(int )>(_a, &SettingsCache::redirectCacheTtlChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(int )>(_a, &SettingsCache::masterVolumeChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::chatMentionCompleterChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::downloadSpoilerTimeIndexChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)()>(_a, &SettingsCache::downloadSpoilerStatusChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(bool )>(_a, &SettingsCache::useTearOffMenusChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (SettingsCache::*)(bool )>(_a, &SettingsCache::roundCardCornersChanged, 35))
            return;
    }
}

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

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

int SettingsCache::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 < 139)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 139;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 139)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 139;
    }
    return _id;
}

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

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

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

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

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

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

// SIGNAL 6
void SettingsCache::overrideAllCardArtWithPersonalPreferenceChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 6, nullptr, _t1);
}

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

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

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

// SIGNAL 10
void SettingsCache::includeRebalancedCardsChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 10, nullptr, _t1);
}

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

// SIGNAL 12
void SettingsCache::visualDeckStorageShowTagFilterChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void SettingsCache::visualDeckStorageShowBannerCardComboBoxChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void SettingsCache::visualDeckStorageShowTagsOnDeckPreviewsChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

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

// SIGNAL 16
void SettingsCache::visualDeckStorageDrawUnusedColorIdentitiesChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void SettingsCache::visualDeckStorageUnusedColorIdentitiesOpacityChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void SettingsCache::visualDeckStorageInGameChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

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

// SIGNAL 20
void SettingsCache::handJustificationChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 20, nullptr);
}

// SIGNAL 21
void SettingsCache::invertVerticalCoordinateChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 21, nullptr);
}

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

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

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

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

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

// SIGNAL 27
void SettingsCache::pixmapCacheSizeChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 27, nullptr, _t1);
}

// SIGNAL 28
void SettingsCache::networkCacheSizeChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1);
}

// SIGNAL 29
void SettingsCache::redirectCacheTtlChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1);
}

// SIGNAL 30
void SettingsCache::masterVolumeChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1);
}

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

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

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

// SIGNAL 34
void SettingsCache::useTearOffMenusChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1);
}

// SIGNAL 35
void SettingsCache::roundCardCornersChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 35, nullptr, _t1);
}
QT_WARNING_POP
