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

#include "../../../../../dde-control-center/src/plugin-datetime/operation/datetimemodel.h"
#include <QtCore/qmetatype.h>

#include <QtCore/qtmochelpers.h>

#include <memory>


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

template <> constexpr inline auto DatetimeModel::qt_create_metaobjectdata<qt_meta_tag_ZN13DatetimeModelE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "DatetimeModel",
        "ntpChanged",
        "",
        "value",
        "hourTypeChanged",
        "userTimeZoneAdded",
        "ZoneInfo",
        "zone",
        "userTimeZoneRemoved",
        "systemTimeZoneIdChanged",
        "systemTimeChanged",
        "currentTimeZoneChanged",
        "currentSystemTimeZoneChanged",
        "NTPServerChanged",
        "server",
        "NTPServerListChanged",
        "list",
        "NTPServerNotChanged",
        "timeZoneChanged",
        "localeNameChanged",
        "localeName",
        "countryChanged",
        "country",
        "langCountryChanged",
        "langCountry",
        "firstDayOfWeekFormatChanged",
        "firstDayOfWeekFormat",
        "shortDateFormatChanged",
        "shortDateFormat",
        "longDateFormatChanged",
        "longDate",
        "shortTimeFormatChanged",
        "shortTimeFormat",
        "longTimeFormatChanged",
        "longTimeFormat",
        "currencyFormatChanged",
        "oldFormat",
        "newFormat",
        "digitGroupingSymbolChanged",
        "numberFormatChanged",
        "numberFormat",
        "paperFormatChanged",
        "langListChanged",
        "langList",
        "currentLangChanged",
        "lang",
        "currentLanguageAndRegionChanged",
        "weekdayFormatChanged",
        "format",
        "symbolChanged",
        "symbol",
        "countriesChanged",
        "countries",
        "regionChanged",
        "region",
        "currentRegionIndexChanged",
        "index",
        "currentDateChanged",
        "currentTimeChanged",
        "currentFormatChanged",
        "langStateChanged",
        "state",
        "set24HourFormat",
        "setDateTime",
        "dateTime",
        "zones",
        "x",
        "y",
        "map_width",
        "map_height",
        "zonePosition",
        "QPoint",
        "timezone",
        "zoneIdList",
        "zoneDisplayName",
        "zoneName",
        "userTimezoneModel",
        "QAbstractListModel*",
        "zoneSearchModel",
        "QSortFilterProxyModel*",
        "langSearchModel",
        "langRegionSearchModel",
        "regionSearchModel",
        "timeDateModel",
        "currencyModel",
        "decimalModel",
        "currentRegionIndex",
        "setRegion",
        "addUserTimeZoneById",
        "zoneId",
        "removeUserTimeZoneById",
        "name",
        "setSystemTimeZone",
        "timeZoneDescription",
        "ensureLangModel",
        "addLang",
        "deleteLang",
        "setCurrentLang",
        "languagesAndRegions",
        "currentLanguageAndRegion",
        "currentLanguageAndRegionIndex",
        "setCurrentLocaleAndLangRegion",
        "langAndRegion",
        "availableFormats",
        "currentFormatIndex",
        "setCurrentFormat",
        "currentDate",
        "currentTime",
        "ntpEnabled",
        "use24HourFormat",
        "ntpServerAddress",
        "ntpServerList",
        "timeZoneDispalyName",
        "currentTimeZoneIndex",
        "systemTimeZone",
        "currentLang",
        "langRegion",
        "weekdayFormat",
        "firstDayOfWeek",
        "longDateFormat",
        "digitGroupingSymbol",
        "langState"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'ntpChanged'
        QtMocHelpers::SignalData<void(bool)>(1, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'hourTypeChanged'
        QtMocHelpers::SignalData<void(bool)>(4, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 3 },
        }}),
        // Signal 'userTimeZoneAdded'
        QtMocHelpers::SignalData<void(const ZoneInfo &)>(5, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Signal 'userTimeZoneRemoved'
        QtMocHelpers::SignalData<void(const ZoneInfo &)>(8, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Signal 'systemTimeZoneIdChanged'
        QtMocHelpers::SignalData<void(const QString &)>(9, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 7 },
        }}),
        // Signal 'systemTimeChanged'
        QtMocHelpers::SignalData<void()>(10, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'currentTimeZoneChanged'
        QtMocHelpers::SignalData<void(const ZoneInfo &) const>(11, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Signal 'currentSystemTimeZoneChanged'
        QtMocHelpers::SignalData<void(const ZoneInfo &) const>(12, 2, QMC::AccessPublic, QMetaType::Void, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Signal 'NTPServerChanged'
        QtMocHelpers::SignalData<void(QString)>(13, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 14 },
        }}),
        // Signal 'NTPServerListChanged'
        QtMocHelpers::SignalData<void(QStringList)>(15, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 16 },
        }}),
        // Signal 'NTPServerNotChanged'
        QtMocHelpers::SignalData<void(QString)>(17, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 14 },
        }}),
        // Signal 'timeZoneChanged'
        QtMocHelpers::SignalData<void(QString)>(18, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 3 },
        }}),
        // Signal 'localeNameChanged'
        QtMocHelpers::SignalData<void(const QString &)>(19, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 20 },
        }}),
        // Signal 'countryChanged'
        QtMocHelpers::SignalData<void(const QString &)>(21, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 22 },
        }}),
        // Signal 'langCountryChanged'
        QtMocHelpers::SignalData<void(const QString &)>(23, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 24 },
        }}),
        // Signal 'firstDayOfWeekFormatChanged'
        QtMocHelpers::SignalData<void(const int)>(25, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 26 },
        }}),
        // Signal 'shortDateFormatChanged'
        QtMocHelpers::SignalData<void(const QString &)>(27, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 28 },
        }}),
        // Signal 'longDateFormatChanged'
        QtMocHelpers::SignalData<void(const QString &)>(29, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 30 },
        }}),
        // Signal 'shortTimeFormatChanged'
        QtMocHelpers::SignalData<void(const QString &)>(31, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 32 },
        }}),
        // Signal 'longTimeFormatChanged'
        QtMocHelpers::SignalData<void(const QString &)>(33, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 34 },
        }}),
        // Signal 'currencyFormatChanged'
        QtMocHelpers::SignalData<void(const QString &, const QString &)>(35, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 36 }, { QMetaType::QString, 37 },
        }}),
        // Signal 'digitGroupingSymbolChanged'
        QtMocHelpers::SignalData<void(const QString &, const QString &)>(38, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 36 }, { QMetaType::QString, 37 },
        }}),
        // Signal 'numberFormatChanged'
        QtMocHelpers::SignalData<void(const QString &)>(39, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 40 },
        }}),
        // Signal 'paperFormatChanged'
        QtMocHelpers::SignalData<void(const QString &)>(41, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 40 },
        }}),
        // Signal 'langListChanged'
        QtMocHelpers::SignalData<void(const QStringList &)>(42, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 43 },
        }}),
        // Signal 'currentLangChanged'
        QtMocHelpers::SignalData<void(const QString &)>(44, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 45 },
        }}),
        // Signal 'currentLanguageAndRegionChanged'
        QtMocHelpers::SignalData<void(const QString &)>(46, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 45 },
        }}),
        // Signal 'weekdayFormatChanged'
        QtMocHelpers::SignalData<void(int)>(47, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 48 },
        }}),
        // Signal 'symbolChanged'
        QtMocHelpers::SignalData<void(int, const QString &)>(49, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 48 }, { QMetaType::QString, 50 },
        }}),
        // Signal 'countriesChanged'
        QtMocHelpers::SignalData<void(const QStringList &)>(51, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QStringList, 52 },
        }}),
        // Signal 'regionChanged'
        QtMocHelpers::SignalData<void(const QString &)>(53, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 54 },
        }}),
        // Signal 'currentRegionIndexChanged'
        QtMocHelpers::SignalData<void(int)>(55, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 56 },
        }}),
        // Signal 'currentDateChanged'
        QtMocHelpers::SignalData<void()>(57, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'currentTimeChanged'
        QtMocHelpers::SignalData<void()>(58, 2, QMC::AccessPublic, QMetaType::Void),
        // Signal 'currentFormatChanged'
        QtMocHelpers::SignalData<void(int)>(59, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 48 },
        }}),
        // Signal 'langStateChanged'
        QtMocHelpers::SignalData<void(int)>(60, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 61 },
        }}),
        // Slot 'set24HourFormat'
        QtMocHelpers::SlotData<void(bool)>(62, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 61 },
        }}),
        // Slot 'setDateTime'
        QtMocHelpers::SlotData<void(const QDateTime &)>(63, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QDateTime, 64 },
        }}),
        // Slot 'zones'
        QtMocHelpers::SlotData<QStringList(int, int, int, int)>(65, 2, QMC::AccessPublic, QMetaType::QStringList, {{
            { QMetaType::Int, 66 }, { QMetaType::Int, 67 }, { QMetaType::Int, 68 }, { QMetaType::Int, 69 },
        }}),
        // Slot 'zonePosition'
        QtMocHelpers::SlotData<QPoint(const QString &, int, int)>(70, 2, QMC::AccessPublic, 0x80000000 | 71, {{
            { QMetaType::QString, 72 }, { QMetaType::Int, 68 }, { QMetaType::Int, 69 },
        }}),
        // Slot 'zoneIdList'
        QtMocHelpers::SlotData<QStringList()>(73, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Slot 'zoneDisplayName'
        QtMocHelpers::SlotData<QString(const QString &)>(74, 2, QMC::AccessPublic, QMetaType::QString, {{
            { QMetaType::QString, 75 },
        }}),
        // Slot 'userTimezoneModel'
        QtMocHelpers::SlotData<QAbstractListModel *()>(76, 2, QMC::AccessPublic, 0x80000000 | 77),
        // Slot 'zoneSearchModel'
        QtMocHelpers::SlotData<QSortFilterProxyModel *()>(78, 2, QMC::AccessPublic, 0x80000000 | 79),
        // Slot 'langSearchModel'
        QtMocHelpers::SlotData<QSortFilterProxyModel *()>(80, 2, QMC::AccessPublic, 0x80000000 | 79),
        // Slot 'langRegionSearchModel'
        QtMocHelpers::SlotData<QSortFilterProxyModel *()>(81, 2, QMC::AccessPublic, 0x80000000 | 79),
        // Slot 'regionSearchModel'
        QtMocHelpers::SlotData<QSortFilterProxyModel *()>(82, 2, QMC::AccessPublic, 0x80000000 | 79),
        // Slot 'timeDateModel'
        QtMocHelpers::SlotData<QAbstractListModel *()>(83, 2, QMC::AccessPublic, 0x80000000 | 77),
        // Slot 'currencyModel'
        QtMocHelpers::SlotData<QAbstractListModel *()>(84, 2, QMC::AccessPublic, 0x80000000 | 77),
        // Slot 'decimalModel'
        QtMocHelpers::SlotData<QAbstractListModel *()>(85, 2, QMC::AccessPublic, 0x80000000 | 77),
        // Slot 'region'
        QtMocHelpers::SlotData<QString()>(54, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'currentRegionIndex'
        QtMocHelpers::SlotData<int()>(86, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setRegion'
        QtMocHelpers::SlotData<void(const QString &)>(87, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 54 },
        }}),
        // Slot 'addUserTimeZoneById'
        QtMocHelpers::SlotData<void(const QString &)>(88, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 89 },
        }}),
        // Slot 'removeUserTimeZoneById'
        QtMocHelpers::SlotData<void(const QString &)>(90, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 91 },
        }}),
        // Slot 'setSystemTimeZone'
        QtMocHelpers::SlotData<void(const QString &)>(92, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 89 },
        }}),
        // Slot 'timeZoneDescription'
        QtMocHelpers::SlotData<QString(const ZoneInfo &) const>(93, 2, QMC::AccessPublic, QMetaType::QString, {{
            { 0x80000000 | 6, 7 },
        }}),
        // Slot 'ensureLangModel'
        QtMocHelpers::SlotData<void()>(94, 2, QMC::AccessPublic, QMetaType::Void),
        // Slot 'addLang'
        QtMocHelpers::SlotData<void(const QString &)>(95, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 45 },
        }}),
        // Slot 'deleteLang'
        QtMocHelpers::SlotData<void(const QString &)>(96, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 45 },
        }}),
        // Slot 'setCurrentLang'
        QtMocHelpers::SlotData<void(const QString &)>(97, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 45 },
        }}),
        // Slot 'languagesAndRegions'
        QtMocHelpers::SlotData<QStringList()>(98, 2, QMC::AccessPublic, QMetaType::QStringList),
        // Slot 'currentLanguageAndRegion'
        QtMocHelpers::SlotData<QString()>(99, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'currentLanguageAndRegionIndex'
        QtMocHelpers::SlotData<int()>(100, 2, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setCurrentLocaleAndLangRegion'
        QtMocHelpers::SlotData<void(const QString &, const QString &)>(101, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 20 }, { QMetaType::QString, 102 },
        }}),
        // Slot 'availableFormats'
        QtMocHelpers::SlotData<QStringList(int)>(103, 2, QMC::AccessPublic, QMetaType::QStringList, {{
            { QMetaType::Int, 48 },
        }}),
        // Slot 'currentFormatIndex'
        QtMocHelpers::SlotData<int(int)>(104, 2, QMC::AccessPublic, QMetaType::Int, {{
            { QMetaType::Int, 48 },
        }}),
        // Slot 'setCurrentFormat'
        QtMocHelpers::SlotData<void(int, int)>(105, 2, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 48 }, { QMetaType::Int, 56 },
        }}),
        // Slot 'currentDate'
        QtMocHelpers::SlotData<QString()>(106, 2, QMC::AccessPublic, QMetaType::QString),
        // Slot 'currentTime'
        QtMocHelpers::SlotData<QString() const>(107, 2, QMC::AccessPublic, QMetaType::QString),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'ntpEnabled'
        QtMocHelpers::PropertyData<bool>(108, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::Final, 0),
        // property 'use24HourFormat'
        QtMocHelpers::PropertyData<bool>(109, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::Final, 1),
        // property 'ntpServerAddress'
        QtMocHelpers::PropertyData<QString>(110, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 8),
        // property 'ntpServerList'
        QtMocHelpers::PropertyData<QStringList>(111, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable | QMC::Final, 9),
        // property 'timeZoneDispalyName'
        QtMocHelpers::PropertyData<QString>(112, QMetaType::QString, QMC::DefaultPropertyFlags, 7),
        // property 'currentTimeZoneIndex'
        QtMocHelpers::PropertyData<int>(113, QMetaType::Int, QMC::DefaultPropertyFlags, 7),
        // property 'systemTimeZone'
        QtMocHelpers::PropertyData<QString>(114, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::Final, 11),
        // property 'country'
        QtMocHelpers::PropertyData<QString>(22, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 13),
        // property 'countries'
        QtMocHelpers::PropertyData<QStringList>(52, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 29),
        // property 'region'
        QtMocHelpers::PropertyData<QString>(54, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 30),
        // property 'currentRegionIndex'
        QtMocHelpers::PropertyData<int>(86, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Final, 31),
        // property 'langList'
        QtMocHelpers::PropertyData<QStringList>(43, QMetaType::QStringList, QMC::DefaultPropertyFlags | QMC::Final, 24),
        // property 'currentLang'
        QtMocHelpers::PropertyData<QString>(115, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Final, 25),
        // property 'langRegion'
        QtMocHelpers::PropertyData<QString>(116, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 14),
        // property 'weekdayFormat'
        QtMocHelpers::PropertyData<int>(117, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 27),
        // property 'firstDayOfWeek'
        QtMocHelpers::PropertyData<int>(118, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 15),
        // property 'shortDateFormat'
        QtMocHelpers::PropertyData<QString>(28, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 16),
        // property 'longDateFormat'
        QtMocHelpers::PropertyData<QString>(119, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 17),
        // property 'shortTimeFormat'
        QtMocHelpers::PropertyData<QString>(32, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 18),
        // property 'longTimeFormat'
        QtMocHelpers::PropertyData<QString>(34, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 19),
        // property 'currentLanguageAndRegion'
        QtMocHelpers::PropertyData<QString>(99, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Final, 26),
        // property 'currentDate'
        QtMocHelpers::PropertyData<QString>(106, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Final, 32),
        // property 'currentTime'
        QtMocHelpers::PropertyData<QString>(107, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Final, 33),
        // property 'digitGroupingSymbol'
        QtMocHelpers::PropertyData<QString>(120, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet | QMC::Final, 21),
        // property 'langState'
        QtMocHelpers::PropertyData<int>(121, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Final, 35),
    };
    QtMocHelpers::UintData qt_enums {
    };
    return QtMocHelpers::metaObjectData<DatetimeModel, qt_meta_tag_ZN13DatetimeModelE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums);
}
Q_CONSTINIT const QMetaObject DatetimeModel::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13DatetimeModelE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN13DatetimeModelE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN13DatetimeModelE_t>.metaTypes,
    nullptr
} };

void DatetimeModel::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<DatetimeModel *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->ntpChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 1: _t->hourTypeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 2: _t->userTimeZoneAdded((*reinterpret_cast<std::add_pointer_t<ZoneInfo>>(_a[1]))); break;
        case 3: _t->userTimeZoneRemoved((*reinterpret_cast<std::add_pointer_t<ZoneInfo>>(_a[1]))); break;
        case 4: _t->systemTimeZoneIdChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 5: _t->systemTimeChanged(); break;
        case 6: _t->currentTimeZoneChanged((*reinterpret_cast<std::add_pointer_t<ZoneInfo>>(_a[1]))); break;
        case 7: _t->currentSystemTimeZoneChanged((*reinterpret_cast<std::add_pointer_t<ZoneInfo>>(_a[1]))); break;
        case 8: _t->NTPServerChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 9: _t->NTPServerListChanged((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 10: _t->NTPServerNotChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 11: _t->timeZoneChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 12: _t->localeNameChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 13: _t->countryChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 14: _t->langCountryChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 15: _t->firstDayOfWeekFormatChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 16: _t->shortDateFormatChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 17: _t->longDateFormatChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 18: _t->shortTimeFormatChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 19: _t->longTimeFormatChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 20: _t->currencyFormatChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 21: _t->digitGroupingSymbolChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 22: _t->numberFormatChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 23: _t->paperFormatChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 24: _t->langListChanged((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 25: _t->currentLangChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 26: _t->currentLanguageAndRegionChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 27: _t->weekdayFormatChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 28: _t->symbolChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 29: _t->countriesChanged((*reinterpret_cast<std::add_pointer_t<QStringList>>(_a[1]))); break;
        case 30: _t->regionChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 31: _t->currentRegionIndexChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 32: _t->currentDateChanged(); break;
        case 33: _t->currentTimeChanged(); break;
        case 34: _t->currentFormatChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 35: _t->langStateChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 36: _t->set24HourFormat((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 37: _t->setDateTime((*reinterpret_cast<std::add_pointer_t<QDateTime>>(_a[1]))); break;
        case 38: { QStringList _r = _t->zones((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[4])));
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 39: { QPoint _r = _t->zonePosition((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[3])));
            if (_a[0]) *reinterpret_cast<QPoint*>(_a[0]) = std::move(_r); }  break;
        case 40: { QStringList _r = _t->zoneIdList();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 41: { QString _r = _t->zoneDisplayName((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 42: { QAbstractListModel* _r = _t->userTimezoneModel();
            if (_a[0]) *reinterpret_cast<QAbstractListModel**>(_a[0]) = std::move(_r); }  break;
        case 43: { QSortFilterProxyModel* _r = _t->zoneSearchModel();
            if (_a[0]) *reinterpret_cast<QSortFilterProxyModel**>(_a[0]) = std::move(_r); }  break;
        case 44: { QSortFilterProxyModel* _r = _t->langSearchModel();
            if (_a[0]) *reinterpret_cast<QSortFilterProxyModel**>(_a[0]) = std::move(_r); }  break;
        case 45: { QSortFilterProxyModel* _r = _t->langRegionSearchModel();
            if (_a[0]) *reinterpret_cast<QSortFilterProxyModel**>(_a[0]) = std::move(_r); }  break;
        case 46: { QSortFilterProxyModel* _r = _t->regionSearchModel();
            if (_a[0]) *reinterpret_cast<QSortFilterProxyModel**>(_a[0]) = std::move(_r); }  break;
        case 47: { QAbstractListModel* _r = _t->timeDateModel();
            if (_a[0]) *reinterpret_cast<QAbstractListModel**>(_a[0]) = std::move(_r); }  break;
        case 48: { QAbstractListModel* _r = _t->currencyModel();
            if (_a[0]) *reinterpret_cast<QAbstractListModel**>(_a[0]) = std::move(_r); }  break;
        case 49: { QAbstractListModel* _r = _t->decimalModel();
            if (_a[0]) *reinterpret_cast<QAbstractListModel**>(_a[0]) = std::move(_r); }  break;
        case 50: { QString _r = _t->region();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 51: { int _r = _t->currentRegionIndex();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 52: _t->setRegion((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 53: _t->addUserTimeZoneById((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 54: _t->removeUserTimeZoneById((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 55: _t->setSystemTimeZone((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 56: { QString _r = _t->timeZoneDescription((*reinterpret_cast<std::add_pointer_t<ZoneInfo>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 57: _t->ensureLangModel(); break;
        case 58: _t->addLang((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 59: _t->deleteLang((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 60: _t->setCurrentLang((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 61: { QStringList _r = _t->languagesAndRegions();
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 62: { QString _r = _t->currentLanguageAndRegion();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 63: { int _r = _t->currentLanguageAndRegionIndex();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 64: _t->setCurrentLocaleAndLangRegion((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 65: { QStringList _r = _t->availableFormats((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<QStringList*>(_a[0]) = std::move(_r); }  break;
        case 66: { int _r = _t->currentFormatIndex((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])));
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 67: _t->setCurrentFormat((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 68: { QString _r = _t->currentDate();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 69: { QString _r = _t->currentTime();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 2:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ZoneInfo >(); break;
            }
            break;
        case 3:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ZoneInfo >(); break;
            }
            break;
        case 6:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ZoneInfo >(); break;
            }
            break;
        case 7:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ZoneInfo >(); break;
            }
            break;
        case 56:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 0:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< ZoneInfo >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(bool )>(_a, &DatetimeModel::ntpChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(bool )>(_a, &DatetimeModel::hourTypeChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const ZoneInfo & )>(_a, &DatetimeModel::userTimeZoneAdded, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const ZoneInfo & )>(_a, &DatetimeModel::userTimeZoneRemoved, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & )>(_a, &DatetimeModel::systemTimeZoneIdChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)()>(_a, &DatetimeModel::systemTimeChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const ZoneInfo & ) const>(_a, &DatetimeModel::currentTimeZoneChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const ZoneInfo & ) const>(_a, &DatetimeModel::currentSystemTimeZoneChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(QString )>(_a, &DatetimeModel::NTPServerChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(QStringList )>(_a, &DatetimeModel::NTPServerListChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(QString )>(_a, &DatetimeModel::NTPServerNotChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(QString )>(_a, &DatetimeModel::timeZoneChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & )>(_a, &DatetimeModel::localeNameChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & )>(_a, &DatetimeModel::countryChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & )>(_a, &DatetimeModel::langCountryChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const int )>(_a, &DatetimeModel::firstDayOfWeekFormatChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & )>(_a, &DatetimeModel::shortDateFormatChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & )>(_a, &DatetimeModel::longDateFormatChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & )>(_a, &DatetimeModel::shortTimeFormatChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & )>(_a, &DatetimeModel::longTimeFormatChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & , const QString & )>(_a, &DatetimeModel::currencyFormatChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & , const QString & )>(_a, &DatetimeModel::digitGroupingSymbolChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & )>(_a, &DatetimeModel::numberFormatChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & )>(_a, &DatetimeModel::paperFormatChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QStringList & )>(_a, &DatetimeModel::langListChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & )>(_a, &DatetimeModel::currentLangChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & )>(_a, &DatetimeModel::currentLanguageAndRegionChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(int )>(_a, &DatetimeModel::weekdayFormatChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(int , const QString & )>(_a, &DatetimeModel::symbolChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QStringList & )>(_a, &DatetimeModel::countriesChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(const QString & )>(_a, &DatetimeModel::regionChanged, 30))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(int )>(_a, &DatetimeModel::currentRegionIndexChanged, 31))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)()>(_a, &DatetimeModel::currentDateChanged, 32))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)()>(_a, &DatetimeModel::currentTimeChanged, 33))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(int )>(_a, &DatetimeModel::currentFormatChanged, 34))
            return;
        if (QtMocHelpers::indexOfMethod<void (DatetimeModel::*)(int )>(_a, &DatetimeModel::langStateChanged, 35))
            return;
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->nTP(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->use24HourFormat(); break;
        case 2: *reinterpret_cast<QString*>(_v) = _t->ntpServerAddress(); break;
        case 3: *reinterpret_cast<QStringList*>(_v) = _t->ntpServerList(); break;
        case 4: *reinterpret_cast<QString*>(_v) = _t->timeZoneDispalyName(); break;
        case 5: *reinterpret_cast<int*>(_v) = _t->currentTimeZoneIndex(); break;
        case 6: *reinterpret_cast<QString*>(_v) = _t->getTimeZone(); break;
        case 7: *reinterpret_cast<QString*>(_v) = _t->country(); break;
        case 8: *reinterpret_cast<QStringList*>(_v) = _t->countries(); break;
        case 9: *reinterpret_cast<QString*>(_v) = _t->region(); break;
        case 10: *reinterpret_cast<int*>(_v) = _t->currentRegionIndex(); break;
        case 11: *reinterpret_cast<QStringList*>(_v) = _t->langList(); break;
        case 12: *reinterpret_cast<QString*>(_v) = _t->currentLang(); break;
        case 13: *reinterpret_cast<QString*>(_v) = _t->langRegion(); break;
        case 14: *reinterpret_cast<int*>(_v) = _t->weekdayFormat(); break;
        case 15: *reinterpret_cast<int*>(_v) = _t->firstDayOfWeekFormat(); break;
        case 16: *reinterpret_cast<QString*>(_v) = _t->shortDateFormat(); break;
        case 17: *reinterpret_cast<QString*>(_v) = _t->longDateFormat(); break;
        case 18: *reinterpret_cast<QString*>(_v) = _t->shortTimeFormat(); break;
        case 19: *reinterpret_cast<QString*>(_v) = _t->longTimeFormat(); break;
        case 20: *reinterpret_cast<QString*>(_v) = _t->currentLanguageAndRegion(); break;
        case 21: *reinterpret_cast<QString*>(_v) = _t->currentDate(); break;
        case 22: *reinterpret_cast<QString*>(_v) = _t->currentTime(); break;
        case 23: *reinterpret_cast<QString*>(_v) = _t->digitGroupingSymbol(); break;
        case 24: *reinterpret_cast<int*>(_v) = _t->langState(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: _t->setNTP(*reinterpret_cast<bool*>(_v)); break;
        case 1: _t->set24HourFormat(*reinterpret_cast<bool*>(_v)); break;
        case 2: _t->setNtpServerAddress(*reinterpret_cast<QString*>(_v)); break;
        case 3: _t->setNTPServerList(*reinterpret_cast<QStringList*>(_v)); break;
        case 6: _t->setTimeZoneInfo(*reinterpret_cast<QString*>(_v)); break;
        case 7: _t->setCountry(*reinterpret_cast<QString*>(_v)); break;
        case 8: _t->setCountries(*reinterpret_cast<QStringList*>(_v)); break;
        case 9: _t->setRegion(*reinterpret_cast<QString*>(_v)); break;
        case 13: _t->setLangRegion(*reinterpret_cast<QString*>(_v)); break;
        case 14: _t->setWeekdayFormat(*reinterpret_cast<int*>(_v)); break;
        case 15: _t->setFirstDayOfWeek(*reinterpret_cast<int*>(_v)); break;
        case 16: _t->setShortDateFormat(*reinterpret_cast<QString*>(_v)); break;
        case 17: _t->setLongDateFormat(*reinterpret_cast<QString*>(_v)); break;
        case 18: _t->setShortTimeFormat(*reinterpret_cast<QString*>(_v)); break;
        case 19: _t->setLongTimeFormat(*reinterpret_cast<QString*>(_v)); break;
        case 23: _t->setDigitGroupingSymbol(*reinterpret_cast<QString*>(_v)); break;
        default: break;
        }
    }
}

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

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

int DatetimeModel::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 < 70)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 70;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 70)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 70;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 25;
    }
    return _id;
}

// SIGNAL 0
void DatetimeModel::ntpChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 0, nullptr, _t1);
}

// SIGNAL 1
void DatetimeModel::hourTypeChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void DatetimeModel::userTimeZoneAdded(const ZoneInfo & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 2, nullptr, _t1);
}

// SIGNAL 3
void DatetimeModel::userTimeZoneRemoved(const ZoneInfo & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void DatetimeModel::systemTimeZoneIdChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

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

// SIGNAL 6
void DatetimeModel::currentTimeZoneChanged(const ZoneInfo & _t1)const
{
    QMetaObject::activate<void>(const_cast< DatetimeModel *>(this), &staticMetaObject, 6, nullptr, _t1);
}

// SIGNAL 7
void DatetimeModel::currentSystemTimeZoneChanged(const ZoneInfo & _t1)const
{
    QMetaObject::activate<void>(const_cast< DatetimeModel *>(this), &staticMetaObject, 7, nullptr, _t1);
}

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

// SIGNAL 9
void DatetimeModel::NTPServerListChanged(QStringList _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 9, nullptr, _t1);
}

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

// SIGNAL 11
void DatetimeModel::timeZoneChanged(QString _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 11, nullptr, _t1);
}

// SIGNAL 12
void DatetimeModel::localeNameChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 12, nullptr, _t1);
}

// SIGNAL 13
void DatetimeModel::countryChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 13, nullptr, _t1);
}

// SIGNAL 14
void DatetimeModel::langCountryChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 14, nullptr, _t1);
}

// SIGNAL 15
void DatetimeModel::firstDayOfWeekFormatChanged(const int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 15, nullptr, _t1);
}

// SIGNAL 16
void DatetimeModel::shortDateFormatChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 16, nullptr, _t1);
}

// SIGNAL 17
void DatetimeModel::longDateFormatChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 17, nullptr, _t1);
}

// SIGNAL 18
void DatetimeModel::shortTimeFormatChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 18, nullptr, _t1);
}

// SIGNAL 19
void DatetimeModel::longTimeFormatChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 19, nullptr, _t1);
}

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

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

// SIGNAL 22
void DatetimeModel::numberFormatChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 22, nullptr, _t1);
}

// SIGNAL 23
void DatetimeModel::paperFormatChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 23, nullptr, _t1);
}

// SIGNAL 24
void DatetimeModel::langListChanged(const QStringList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 24, nullptr, _t1);
}

// SIGNAL 25
void DatetimeModel::currentLangChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 25, nullptr, _t1);
}

// SIGNAL 26
void DatetimeModel::currentLanguageAndRegionChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 26, nullptr, _t1);
}

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

// SIGNAL 28
void DatetimeModel::symbolChanged(int _t1, const QString & _t2)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 28, nullptr, _t1, _t2);
}

// SIGNAL 29
void DatetimeModel::countriesChanged(const QStringList & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 29, nullptr, _t1);
}

// SIGNAL 30
void DatetimeModel::regionChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 30, nullptr, _t1);
}

// SIGNAL 31
void DatetimeModel::currentRegionIndexChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 31, nullptr, _t1);
}

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

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

// SIGNAL 34
void DatetimeModel::currentFormatChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 34, nullptr, _t1);
}

// SIGNAL 35
void DatetimeModel::langStateChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 35, nullptr, _t1);
}
QT_WARNING_POP
