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

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

#ifndef Q_CONSTINIT
#define Q_CONSTINIT
#endif

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

template <> constexpr inline auto PowerManager::qt_create_metaobjectdata<qt_meta_tag_ZN12PowerManagerE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PowerManager",
        "D-Bus Interface",
        "org.deepin.dde.Power1",
        "onBatteryChanged",
        "",
        "lidIsPresentChanged",
        "batteryIsPresentChanged",
        "batteryPercentageChanged",
        "batteryStateChanged",
        "hasAmbientLightSensorChanged",
        "warnLevelChanged",
        "isHighPerformanceSupportedChanged",
        "linePowerScreensaverDelayChanged",
        "linePowerScreenBlackDelayChanged",
        "linePowerSleepDelayChanged",
        "linePowerLockDelayChanged",
        "batteryScreensaverDelayChanged",
        "batteryScreenBlackDelayChanged",
        "batterySleepDelayChanged",
        "batteryLockDelayChanged",
        "screenBlackLockChanged",
        "sleepLockChanged",
        "linePowerLidClosedActionChanged",
        "batteryLidClosedActionChanged",
        "linePowerPressPowerBtnActionChanged",
        "batteryPressPowerBtnActionChanged",
        "lowPowerNotifyEnableChanged",
        "lowPowerNotifyThresholdChanged",
        "lowPowerAutoSleepThresholdChanged",
        "lowPowerActionChanged",
        "ambientLightAdjustBrightnessChanged",
        "scheduledShutdownStateChanged",
        "shutdownTimeChanged",
        "shutdownRepetitionChanged",
        "customShutdownWeekDaysChanged",
        "Reset",
        "SetPrepareSuspend",
        "state",
        "TurnOffScreen",
        "TurnOnScreen",
        "onBattery",
        "lidIsPresent",
        "batteryIsPresent",
        "BatteryIsPresentMap",
        "batteryPercentage",
        "BatteryPercentageMap",
        "batteryState",
        "BatteryStateMap",
        "batteryTimeToEmpty",
        "hasAmbientLightSensor",
        "warnLevel",
        "isHighPerformanceSupported",
        "linePowerScreensaverDelay",
        "setLinePowerScreensaverDelay",
        "v",
        "linePowerScreenBlackDelay",
        "setLinePowerScreenBlackDelay",
        "linePowerSleepDelay",
        "setLinePowerSleepDelay",
        "linePowerLockDelay",
        "setLinePowerLockDelay",
        "batteryScreensaverDelay",
        "setBatteryScreensaverDelay",
        "batteryScreenBlackDelay",
        "setBatteryScreenBlackDelay",
        "batterySleepDelay",
        "setBatterySleepDelay",
        "batteryLockDelay",
        "setBatteryLockDelay",
        "screenBlackLock",
        "setScreenBlackLock",
        "sleepLock",
        "setSleepLock",
        "linePowerLidClosedAction",
        "setLinePowerLidClosedAction",
        "batteryLidClosedAction",
        "setBatteryLidClosedAction",
        "linePowerPressPowerBtnAction",
        "setLinePowerPressPowerBtnAction",
        "batteryPressPowerBtnAction",
        "setBatteryPressPowerBtnAction",
        "lowPowerNotifyEnable",
        "setLowPowerNotifyEnable",
        "lowPowerNotifyThreshold",
        "setLowPowerNotifyThreshold",
        "lowPowerAutoSleepThreshold",
        "setLowPowerAutoSleepThreshold",
        "lowPowerAction",
        "setLowPowerAction",
        "ambientLightAdjustBrightness",
        "setAmbientLightAdjustBrightness",
        "scheduledShutdownState",
        "setScheduledShutdownState",
        "shutdownTime",
        "setShutdownTime",
        "shutdownRepetition",
        "setShutdownRepetition",
        "customShutdownWeekDays",
        "setCustomShutdownWeekDays",
        "onLogin1OwnerChanged",
        "name",
        "oldOwner",
        "newOwner",
        "onNotifyActionInvoked",
        "id",
        "actionKey",
        "onSystemTimeChanged",
        "onSessionActiveChanged",
        "onLinePowerDelayChanged",
        "onBatteryDelayChanged",
        "handleOnBatteryChanged",
        "value",
        "handleHasLidSwitchChanged",
        "handleHasBatteryChanged",
        "handleBatteryPercentageChanged",
        "handleBatteryStatusChanged",
        "handleBatteryTimeToEmptyChanged",
        "handleIsHighPerformanceSupportedChanged",
        "handlePowerSavingModeEnabledChanged",
        "handlePowerSavingModeBrightnessDropPercentChanged",
        "refreshBatteryInfo",
        "notifyPropertyChanged",
        "OnBattery",
        "LidIsPresent",
        "BatteryIsPresent",
        "BatteryPercentage",
        "BatteryState",
        "HasAmbientLightSensor",
        "WarnLevel",
        "IsHighPerformanceSupported",
        "LinePowerScreensaverDelay",
        "LinePowerScreenBlackDelay",
        "LinePowerSleepDelay",
        "LinePowerLockDelay",
        "BatteryScreensaverDelay",
        "BatteryScreenBlackDelay",
        "BatterySleepDelay",
        "BatteryLockDelay",
        "ScreenBlackLock",
        "SleepLock",
        "LinePowerLidClosedAction",
        "BatteryLidClosedAction",
        "LinePowerPressPowerBtnAction",
        "BatteryPressPowerBtnAction",
        "LowPowerNotifyEnable",
        "LowPowerNotifyThreshold",
        "LowPowerAutoSleepThreshold",
        "LowPowerAction",
        "AmbientLightAdjustBrightness",
        "ScheduledShutdownState",
        "ShutdownTime",
        "ShutdownRepetition",
        "CustomShutdownWeekDays"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'onBatteryChanged'
        QtMocHelpers::SignalData<void()>(3, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lidIsPresentChanged'
        QtMocHelpers::SignalData<void()>(5, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'batteryIsPresentChanged'
        QtMocHelpers::SignalData<void()>(6, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'batteryPercentageChanged'
        QtMocHelpers::SignalData<void()>(7, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'batteryStateChanged'
        QtMocHelpers::SignalData<void()>(8, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'hasAmbientLightSensorChanged'
        QtMocHelpers::SignalData<void()>(9, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'warnLevelChanged'
        QtMocHelpers::SignalData<void()>(10, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'isHighPerformanceSupportedChanged'
        QtMocHelpers::SignalData<void()>(11, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'linePowerScreensaverDelayChanged'
        QtMocHelpers::SignalData<void()>(12, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'linePowerScreenBlackDelayChanged'
        QtMocHelpers::SignalData<void()>(13, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'linePowerSleepDelayChanged'
        QtMocHelpers::SignalData<void()>(14, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'linePowerLockDelayChanged'
        QtMocHelpers::SignalData<void()>(15, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'batteryScreensaverDelayChanged'
        QtMocHelpers::SignalData<void()>(16, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'batteryScreenBlackDelayChanged'
        QtMocHelpers::SignalData<void()>(17, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'batterySleepDelayChanged'
        QtMocHelpers::SignalData<void()>(18, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'batteryLockDelayChanged'
        QtMocHelpers::SignalData<void()>(19, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'screenBlackLockChanged'
        QtMocHelpers::SignalData<void()>(20, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'sleepLockChanged'
        QtMocHelpers::SignalData<void()>(21, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'linePowerLidClosedActionChanged'
        QtMocHelpers::SignalData<void()>(22, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'batteryLidClosedActionChanged'
        QtMocHelpers::SignalData<void()>(23, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'linePowerPressPowerBtnActionChanged'
        QtMocHelpers::SignalData<void()>(24, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'batteryPressPowerBtnActionChanged'
        QtMocHelpers::SignalData<void()>(25, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lowPowerNotifyEnableChanged'
        QtMocHelpers::SignalData<void()>(26, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lowPowerNotifyThresholdChanged'
        QtMocHelpers::SignalData<void()>(27, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lowPowerAutoSleepThresholdChanged'
        QtMocHelpers::SignalData<void()>(28, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'lowPowerActionChanged'
        QtMocHelpers::SignalData<void()>(29, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'ambientLightAdjustBrightnessChanged'
        QtMocHelpers::SignalData<void()>(30, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'scheduledShutdownStateChanged'
        QtMocHelpers::SignalData<void()>(31, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'shutdownTimeChanged'
        QtMocHelpers::SignalData<void()>(32, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'shutdownRepetitionChanged'
        QtMocHelpers::SignalData<void()>(33, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'customShutdownWeekDaysChanged'
        QtMocHelpers::SignalData<void()>(34, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'Reset'
        QtMocHelpers::SlotData<void()>(35, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'SetPrepareSuspend'
        QtMocHelpers::SlotData<void(int)>(36, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 37 },
        }}),
        // Slot 'TurnOffScreen'
        QtMocHelpers::SlotData<void()>(38, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'TurnOnScreen'
        QtMocHelpers::SlotData<void()>(39, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onBattery'
        QtMocHelpers::SlotData<bool() const>(40, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'lidIsPresent'
        QtMocHelpers::SlotData<bool() const>(41, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'batteryIsPresent'
        QtMocHelpers::SlotData<BatteryIsPresentMap() const>(42, 4, QMC::AccessPublic, 0x80000000 | 43),
        // Slot 'batteryPercentage'
        QtMocHelpers::SlotData<BatteryPercentageMap() const>(44, 4, QMC::AccessPublic, 0x80000000 | 45),
        // Slot 'batteryState'
        QtMocHelpers::SlotData<BatteryStateMap() const>(46, 4, QMC::AccessPublic, 0x80000000 | 47),
        // Slot 'batteryTimeToEmpty'
        QtMocHelpers::SlotData<quint64() const>(48, 4, QMC::AccessPublic, QMetaType::ULongLong),
        // Slot 'hasAmbientLightSensor'
        QtMocHelpers::SlotData<bool() const>(49, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'warnLevel'
        QtMocHelpers::SlotData<uint() const>(50, 4, QMC::AccessPublic, QMetaType::UInt),
        // Slot 'isHighPerformanceSupported'
        QtMocHelpers::SlotData<bool() const>(51, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'linePowerScreensaverDelay'
        QtMocHelpers::SlotData<int() const>(52, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLinePowerScreensaverDelay'
        QtMocHelpers::SlotData<void(int)>(53, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'linePowerScreenBlackDelay'
        QtMocHelpers::SlotData<int() const>(55, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLinePowerScreenBlackDelay'
        QtMocHelpers::SlotData<void(int)>(56, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'linePowerSleepDelay'
        QtMocHelpers::SlotData<int() const>(57, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLinePowerSleepDelay'
        QtMocHelpers::SlotData<void(int)>(58, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'linePowerLockDelay'
        QtMocHelpers::SlotData<int() const>(59, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLinePowerLockDelay'
        QtMocHelpers::SlotData<void(int)>(60, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'batteryScreensaverDelay'
        QtMocHelpers::SlotData<int() const>(61, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setBatteryScreensaverDelay'
        QtMocHelpers::SlotData<void(int)>(62, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'batteryScreenBlackDelay'
        QtMocHelpers::SlotData<int() const>(63, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setBatteryScreenBlackDelay'
        QtMocHelpers::SlotData<void(int)>(64, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'batterySleepDelay'
        QtMocHelpers::SlotData<int() const>(65, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setBatterySleepDelay'
        QtMocHelpers::SlotData<void(int)>(66, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'batteryLockDelay'
        QtMocHelpers::SlotData<int() const>(67, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setBatteryLockDelay'
        QtMocHelpers::SlotData<void(int)>(68, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'screenBlackLock'
        QtMocHelpers::SlotData<bool() const>(69, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setScreenBlackLock'
        QtMocHelpers::SlotData<void(bool)>(70, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 54 },
        }}),
        // Slot 'sleepLock'
        QtMocHelpers::SlotData<bool() const>(71, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setSleepLock'
        QtMocHelpers::SlotData<void(bool)>(72, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 54 },
        }}),
        // Slot 'linePowerLidClosedAction'
        QtMocHelpers::SlotData<int() const>(73, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLinePowerLidClosedAction'
        QtMocHelpers::SlotData<void(int)>(74, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'batteryLidClosedAction'
        QtMocHelpers::SlotData<int() const>(75, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setBatteryLidClosedAction'
        QtMocHelpers::SlotData<void(int)>(76, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'linePowerPressPowerBtnAction'
        QtMocHelpers::SlotData<int() const>(77, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLinePowerPressPowerBtnAction'
        QtMocHelpers::SlotData<void(int)>(78, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'batteryPressPowerBtnAction'
        QtMocHelpers::SlotData<int() const>(79, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setBatteryPressPowerBtnAction'
        QtMocHelpers::SlotData<void(int)>(80, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'lowPowerNotifyEnable'
        QtMocHelpers::SlotData<bool() const>(81, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setLowPowerNotifyEnable'
        QtMocHelpers::SlotData<void(bool)>(82, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 54 },
        }}),
        // Slot 'lowPowerNotifyThreshold'
        QtMocHelpers::SlotData<int() const>(83, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLowPowerNotifyThreshold'
        QtMocHelpers::SlotData<void(int)>(84, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'lowPowerAutoSleepThreshold'
        QtMocHelpers::SlotData<int() const>(85, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLowPowerAutoSleepThreshold'
        QtMocHelpers::SlotData<void(int)>(86, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'lowPowerAction'
        QtMocHelpers::SlotData<int() const>(87, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setLowPowerAction'
        QtMocHelpers::SlotData<void(int)>(88, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'ambientLightAdjustBrightness'
        QtMocHelpers::SlotData<bool() const>(89, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setAmbientLightAdjustBrightness'
        QtMocHelpers::SlotData<void(bool)>(90, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 54 },
        }}),
        // Slot 'scheduledShutdownState'
        QtMocHelpers::SlotData<bool() const>(91, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'setScheduledShutdownState'
        QtMocHelpers::SlotData<void(bool)>(92, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 54 },
        }}),
        // Slot 'shutdownTime'
        QtMocHelpers::SlotData<QString() const>(93, 4, QMC::AccessPublic, QMetaType::QString),
        // Slot 'setShutdownTime'
        QtMocHelpers::SlotData<void(const QString &)>(94, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 54 },
        }}),
        // Slot 'shutdownRepetition'
        QtMocHelpers::SlotData<int() const>(95, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'setShutdownRepetition'
        QtMocHelpers::SlotData<void(int)>(96, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 54 },
        }}),
        // Slot 'customShutdownWeekDays'
        QtMocHelpers::SlotData<QByteArray() const>(97, 4, QMC::AccessPublic, QMetaType::QByteArray),
        // Slot 'setCustomShutdownWeekDays'
        QtMocHelpers::SlotData<void(const QByteArray &)>(98, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QByteArray, 54 },
        }}),
        // Slot 'onLogin1OwnerChanged'
        QtMocHelpers::SlotData<void(const QString &, const QString &, const QString &)>(99, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 100 }, { QMetaType::QString, 101 }, { QMetaType::QString, 102 },
        }}),
        // Slot 'onNotifyActionInvoked'
        QtMocHelpers::SlotData<void(uint, const QString &)>(103, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::UInt, 104 }, { QMetaType::QString, 105 },
        }}),
        // Slot 'onSystemTimeChanged'
        QtMocHelpers::SlotData<void()>(106, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onSessionActiveChanged'
        QtMocHelpers::SlotData<void()>(107, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onLinePowerDelayChanged'
        QtMocHelpers::SlotData<void()>(108, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onBatteryDelayChanged'
        QtMocHelpers::SlotData<void()>(109, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'handleOnBatteryChanged'
        QtMocHelpers::SlotData<void(bool)>(110, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 111 },
        }}),
        // Slot 'handleHasLidSwitchChanged'
        QtMocHelpers::SlotData<void(bool)>(112, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 111 },
        }}),
        // Slot 'handleHasBatteryChanged'
        QtMocHelpers::SlotData<void(bool)>(113, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 111 },
        }}),
        // Slot 'handleBatteryPercentageChanged'
        QtMocHelpers::SlotData<void(double)>(114, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Double, 111 },
        }}),
        // Slot 'handleBatteryStatusChanged'
        QtMocHelpers::SlotData<void(uint)>(115, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::UInt, 111 },
        }}),
        // Slot 'handleBatteryTimeToEmptyChanged'
        QtMocHelpers::SlotData<void(quint64)>(116, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::ULongLong, 111 },
        }}),
        // Slot 'handleIsHighPerformanceSupportedChanged'
        QtMocHelpers::SlotData<void(bool)>(117, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 111 },
        }}),
        // Slot 'handlePowerSavingModeEnabledChanged'
        QtMocHelpers::SlotData<void(bool)>(118, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 111 },
        }}),
        // Slot 'handlePowerSavingModeBrightnessDropPercentChanged'
        QtMocHelpers::SlotData<void(uint)>(119, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::UInt, 111 },
        }}),
        // Slot 'refreshBatteryInfo'
        QtMocHelpers::SlotData<void()>(120, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'notifyPropertyChanged'
        QtMocHelpers::SlotData<void()>(121, 4, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
        // property 'OnBattery'
        QtMocHelpers::PropertyData<bool>(122, QMetaType::Bool, QMC::DefaultPropertyFlags, 0),
        // property 'LidIsPresent'
        QtMocHelpers::PropertyData<bool>(123, QMetaType::Bool, QMC::DefaultPropertyFlags, 1),
        // property 'BatteryIsPresent'
        QtMocHelpers::PropertyData<BatteryIsPresentMap>(124, 0x80000000 | 43, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 2),
        // property 'BatteryPercentage'
        QtMocHelpers::PropertyData<BatteryPercentageMap>(125, 0x80000000 | 45, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 3),
        // property 'BatteryState'
        QtMocHelpers::PropertyData<BatteryStateMap>(126, 0x80000000 | 47, QMC::DefaultPropertyFlags | QMC::EnumOrFlag, 4),
        // property 'HasAmbientLightSensor'
        QtMocHelpers::PropertyData<bool>(127, QMetaType::Bool, QMC::DefaultPropertyFlags, 5),
        // property 'WarnLevel'
        QtMocHelpers::PropertyData<uint>(128, QMetaType::UInt, QMC::DefaultPropertyFlags, 6),
        // property 'IsHighPerformanceSupported'
        QtMocHelpers::PropertyData<bool>(129, QMetaType::Bool, QMC::DefaultPropertyFlags, 7),
        // property 'LinePowerScreensaverDelay'
        QtMocHelpers::PropertyData<int>(130, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 8),
        // property 'LinePowerScreenBlackDelay'
        QtMocHelpers::PropertyData<int>(131, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 9),
        // property 'LinePowerSleepDelay'
        QtMocHelpers::PropertyData<int>(132, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 10),
        // property 'LinePowerLockDelay'
        QtMocHelpers::PropertyData<int>(133, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 11),
        // property 'BatteryScreensaverDelay'
        QtMocHelpers::PropertyData<int>(134, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 12),
        // property 'BatteryScreenBlackDelay'
        QtMocHelpers::PropertyData<int>(135, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 13),
        // property 'BatterySleepDelay'
        QtMocHelpers::PropertyData<int>(136, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 14),
        // property 'BatteryLockDelay'
        QtMocHelpers::PropertyData<int>(137, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 15),
        // property 'ScreenBlackLock'
        QtMocHelpers::PropertyData<bool>(138, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 16),
        // property 'SleepLock'
        QtMocHelpers::PropertyData<bool>(139, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 17),
        // property 'LinePowerLidClosedAction'
        QtMocHelpers::PropertyData<int>(140, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 18),
        // property 'BatteryLidClosedAction'
        QtMocHelpers::PropertyData<int>(141, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 19),
        // property 'LinePowerPressPowerBtnAction'
        QtMocHelpers::PropertyData<int>(142, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 20),
        // property 'BatteryPressPowerBtnAction'
        QtMocHelpers::PropertyData<int>(143, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 21),
        // property 'LowPowerNotifyEnable'
        QtMocHelpers::PropertyData<bool>(144, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 22),
        // property 'LowPowerNotifyThreshold'
        QtMocHelpers::PropertyData<int>(145, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 23),
        // property 'LowPowerAutoSleepThreshold'
        QtMocHelpers::PropertyData<int>(146, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 24),
        // property 'LowPowerAction'
        QtMocHelpers::PropertyData<int>(147, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 25),
        // property 'AmbientLightAdjustBrightness'
        QtMocHelpers::PropertyData<bool>(148, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 26),
        // property 'ScheduledShutdownState'
        QtMocHelpers::PropertyData<bool>(149, QMetaType::Bool, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 27),
        // property 'ShutdownTime'
        QtMocHelpers::PropertyData<QString>(150, QMetaType::QString, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 28),
        // property 'ShutdownRepetition'
        QtMocHelpers::PropertyData<int>(151, QMetaType::Int, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 29),
        // property 'CustomShutdownWeekDays'
        QtMocHelpers::PropertyData<QByteArray>(152, QMetaType::QByteArray, QMC::DefaultPropertyFlags | QMC::Writable | QMC::StdCppSet, 30),
    };
    QtMocHelpers::UintData qt_enums {
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<PowerManager, qt_meta_tag_ZN12PowerManagerE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject PowerManager::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12PowerManagerE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN12PowerManagerE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN12PowerManagerE_t>.metaTypes,
    nullptr
} };

void PowerManager::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<PowerManager *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->onBatteryChanged(); break;
        case 1: _t->lidIsPresentChanged(); break;
        case 2: _t->batteryIsPresentChanged(); break;
        case 3: _t->batteryPercentageChanged(); break;
        case 4: _t->batteryStateChanged(); break;
        case 5: _t->hasAmbientLightSensorChanged(); break;
        case 6: _t->warnLevelChanged(); break;
        case 7: _t->isHighPerformanceSupportedChanged(); break;
        case 8: _t->linePowerScreensaverDelayChanged(); break;
        case 9: _t->linePowerScreenBlackDelayChanged(); break;
        case 10: _t->linePowerSleepDelayChanged(); break;
        case 11: _t->linePowerLockDelayChanged(); break;
        case 12: _t->batteryScreensaverDelayChanged(); break;
        case 13: _t->batteryScreenBlackDelayChanged(); break;
        case 14: _t->batterySleepDelayChanged(); break;
        case 15: _t->batteryLockDelayChanged(); break;
        case 16: _t->screenBlackLockChanged(); break;
        case 17: _t->sleepLockChanged(); break;
        case 18: _t->linePowerLidClosedActionChanged(); break;
        case 19: _t->batteryLidClosedActionChanged(); break;
        case 20: _t->linePowerPressPowerBtnActionChanged(); break;
        case 21: _t->batteryPressPowerBtnActionChanged(); break;
        case 22: _t->lowPowerNotifyEnableChanged(); break;
        case 23: _t->lowPowerNotifyThresholdChanged(); break;
        case 24: _t->lowPowerAutoSleepThresholdChanged(); break;
        case 25: _t->lowPowerActionChanged(); break;
        case 26: _t->ambientLightAdjustBrightnessChanged(); break;
        case 27: _t->scheduledShutdownStateChanged(); break;
        case 28: _t->shutdownTimeChanged(); break;
        case 29: _t->shutdownRepetitionChanged(); break;
        case 30: _t->customShutdownWeekDaysChanged(); break;
        case 31: _t->Reset(); break;
        case 32: _t->SetPrepareSuspend((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 33: _t->TurnOffScreen(); break;
        case 34: _t->TurnOnScreen(); break;
        case 35: { bool _r = _t->onBattery();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 36: { bool _r = _t->lidIsPresent();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 37: { BatteryIsPresentMap _r = _t->batteryIsPresent();
            if (_a[0]) *reinterpret_cast<BatteryIsPresentMap*>(_a[0]) = std::move(_r); }  break;
        case 38: { BatteryPercentageMap _r = _t->batteryPercentage();
            if (_a[0]) *reinterpret_cast<BatteryPercentageMap*>(_a[0]) = std::move(_r); }  break;
        case 39: { BatteryStateMap _r = _t->batteryState();
            if (_a[0]) *reinterpret_cast<BatteryStateMap*>(_a[0]) = std::move(_r); }  break;
        case 40: { quint64 _r = _t->batteryTimeToEmpty();
            if (_a[0]) *reinterpret_cast<quint64*>(_a[0]) = std::move(_r); }  break;
        case 41: { bool _r = _t->hasAmbientLightSensor();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 42: { uint _r = _t->warnLevel();
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 43: { bool _r = _t->isHighPerformanceSupported();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 44: { int _r = _t->linePowerScreensaverDelay();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 45: _t->setLinePowerScreensaverDelay((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 46: { int _r = _t->linePowerScreenBlackDelay();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 47: _t->setLinePowerScreenBlackDelay((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 48: { int _r = _t->linePowerSleepDelay();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 49: _t->setLinePowerSleepDelay((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 50: { int _r = _t->linePowerLockDelay();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 51: _t->setLinePowerLockDelay((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 52: { int _r = _t->batteryScreensaverDelay();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 53: _t->setBatteryScreensaverDelay((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 54: { int _r = _t->batteryScreenBlackDelay();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 55: _t->setBatteryScreenBlackDelay((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 56: { int _r = _t->batterySleepDelay();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 57: _t->setBatterySleepDelay((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 58: { int _r = _t->batteryLockDelay();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 59: _t->setBatteryLockDelay((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 60: { bool _r = _t->screenBlackLock();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 61: _t->setScreenBlackLock((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 62: { bool _r = _t->sleepLock();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 63: _t->setSleepLock((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 64: { int _r = _t->linePowerLidClosedAction();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 65: _t->setLinePowerLidClosedAction((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 66: { int _r = _t->batteryLidClosedAction();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 67: _t->setBatteryLidClosedAction((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 68: { int _r = _t->linePowerPressPowerBtnAction();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 69: _t->setLinePowerPressPowerBtnAction((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 70: { int _r = _t->batteryPressPowerBtnAction();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 71: _t->setBatteryPressPowerBtnAction((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 72: { bool _r = _t->lowPowerNotifyEnable();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 73: _t->setLowPowerNotifyEnable((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 74: { int _r = _t->lowPowerNotifyThreshold();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 75: _t->setLowPowerNotifyThreshold((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 76: { int _r = _t->lowPowerAutoSleepThreshold();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 77: _t->setLowPowerAutoSleepThreshold((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 78: { int _r = _t->lowPowerAction();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 79: _t->setLowPowerAction((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 80: { bool _r = _t->ambientLightAdjustBrightness();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 81: _t->setAmbientLightAdjustBrightness((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 82: { bool _r = _t->scheduledShutdownState();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 83: _t->setScheduledShutdownState((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 84: { QString _r = _t->shutdownTime();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 85: _t->setShutdownTime((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 86: { int _r = _t->shutdownRepetition();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 87: _t->setShutdownRepetition((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 88: { QByteArray _r = _t->customShutdownWeekDays();
            if (_a[0]) *reinterpret_cast<QByteArray*>(_a[0]) = std::move(_r); }  break;
        case 89: _t->setCustomShutdownWeekDays((*reinterpret_cast<std::add_pointer_t<QByteArray>>(_a[1]))); break;
        case 90: _t->onLogin1OwnerChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[3]))); break;
        case 91: _t->onNotifyActionInvoked((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 92: _t->onSystemTimeChanged(); break;
        case 93: _t->onSessionActiveChanged(); break;
        case 94: _t->onLinePowerDelayChanged(); break;
        case 95: _t->onBatteryDelayChanged(); break;
        case 96: _t->handleOnBatteryChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 97: _t->handleHasLidSwitchChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 98: _t->handleHasBatteryChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 99: _t->handleBatteryPercentageChanged((*reinterpret_cast<std::add_pointer_t<double>>(_a[1]))); break;
        case 100: _t->handleBatteryStatusChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 101: _t->handleBatteryTimeToEmptyChanged((*reinterpret_cast<std::add_pointer_t<quint64>>(_a[1]))); break;
        case 102: _t->handleIsHighPerformanceSupportedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 103: _t->handlePowerSavingModeEnabledChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 104: _t->handlePowerSavingModeBrightnessDropPercentChanged((*reinterpret_cast<std::add_pointer_t<uint>>(_a[1]))); break;
        case 105: _t->refreshBatteryInfo(); break;
        case 106: _t->notifyPropertyChanged(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::onBatteryChanged, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::lidIsPresentChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::batteryIsPresentChanged, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::batteryPercentageChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::batteryStateChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::hasAmbientLightSensorChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::warnLevelChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::isHighPerformanceSupportedChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::linePowerScreensaverDelayChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::linePowerScreenBlackDelayChanged, 9))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::linePowerSleepDelayChanged, 10))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::linePowerLockDelayChanged, 11))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::batteryScreensaverDelayChanged, 12))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::batteryScreenBlackDelayChanged, 13))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::batterySleepDelayChanged, 14))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::batteryLockDelayChanged, 15))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::screenBlackLockChanged, 16))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::sleepLockChanged, 17))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::linePowerLidClosedActionChanged, 18))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::batteryLidClosedActionChanged, 19))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::linePowerPressPowerBtnActionChanged, 20))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::batteryPressPowerBtnActionChanged, 21))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::lowPowerNotifyEnableChanged, 22))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::lowPowerNotifyThresholdChanged, 23))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::lowPowerAutoSleepThresholdChanged, 24))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::lowPowerActionChanged, 25))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::ambientLightAdjustBrightnessChanged, 26))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::scheduledShutdownStateChanged, 27))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::shutdownTimeChanged, 28))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::shutdownRepetitionChanged, 29))
            return;
        if (QtMocHelpers::indexOfMethod<void (PowerManager::*)()>(_a, &PowerManager::customShutdownWeekDaysChanged, 30))
            return;
    }
    if (_c == QMetaObject::RegisterPropertyMetaType) {
        switch (_id) {
        default: *reinterpret_cast<int*>(_a[0]) = -1; break;
        case 2:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< BatteryIsPresentMap >(); break;
        case 3:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< BatteryPercentageMap >(); break;
        case 4:
            *reinterpret_cast<int*>(_a[0]) = qRegisterMetaType< BatteryStateMap >(); break;
        }
    }
    if (_c == QMetaObject::ReadProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 0: *reinterpret_cast<bool*>(_v) = _t->onBattery(); break;
        case 1: *reinterpret_cast<bool*>(_v) = _t->lidIsPresent(); break;
        case 2: *reinterpret_cast<BatteryIsPresentMap*>(_v) = _t->batteryIsPresent(); break;
        case 3: *reinterpret_cast<BatteryPercentageMap*>(_v) = _t->batteryPercentage(); break;
        case 4: *reinterpret_cast<BatteryStateMap*>(_v) = _t->batteryState(); break;
        case 5: *reinterpret_cast<bool*>(_v) = _t->hasAmbientLightSensor(); break;
        case 6: *reinterpret_cast<uint*>(_v) = _t->warnLevel(); break;
        case 7: *reinterpret_cast<bool*>(_v) = _t->isHighPerformanceSupported(); break;
        case 8: *reinterpret_cast<int*>(_v) = _t->linePowerScreensaverDelay(); break;
        case 9: *reinterpret_cast<int*>(_v) = _t->linePowerScreenBlackDelay(); break;
        case 10: *reinterpret_cast<int*>(_v) = _t->linePowerSleepDelay(); break;
        case 11: *reinterpret_cast<int*>(_v) = _t->linePowerLockDelay(); break;
        case 12: *reinterpret_cast<int*>(_v) = _t->batteryScreensaverDelay(); break;
        case 13: *reinterpret_cast<int*>(_v) = _t->batteryScreenBlackDelay(); break;
        case 14: *reinterpret_cast<int*>(_v) = _t->batterySleepDelay(); break;
        case 15: *reinterpret_cast<int*>(_v) = _t->batteryLockDelay(); break;
        case 16: *reinterpret_cast<bool*>(_v) = _t->screenBlackLock(); break;
        case 17: *reinterpret_cast<bool*>(_v) = _t->sleepLock(); break;
        case 18: *reinterpret_cast<int*>(_v) = _t->linePowerLidClosedAction(); break;
        case 19: *reinterpret_cast<int*>(_v) = _t->batteryLidClosedAction(); break;
        case 20: *reinterpret_cast<int*>(_v) = _t->linePowerPressPowerBtnAction(); break;
        case 21: *reinterpret_cast<int*>(_v) = _t->batteryPressPowerBtnAction(); break;
        case 22: *reinterpret_cast<bool*>(_v) = _t->lowPowerNotifyEnable(); break;
        case 23: *reinterpret_cast<int*>(_v) = _t->lowPowerNotifyThreshold(); break;
        case 24: *reinterpret_cast<int*>(_v) = _t->lowPowerAutoSleepThreshold(); break;
        case 25: *reinterpret_cast<int*>(_v) = _t->lowPowerAction(); break;
        case 26: *reinterpret_cast<bool*>(_v) = _t->ambientLightAdjustBrightness(); break;
        case 27: *reinterpret_cast<bool*>(_v) = _t->scheduledShutdownState(); break;
        case 28: *reinterpret_cast<QString*>(_v) = _t->shutdownTime(); break;
        case 29: *reinterpret_cast<int*>(_v) = _t->shutdownRepetition(); break;
        case 30: *reinterpret_cast<QByteArray*>(_v) = _t->customShutdownWeekDays(); break;
        default: break;
        }
    }
    if (_c == QMetaObject::WriteProperty) {
        void *_v = _a[0];
        switch (_id) {
        case 8: _t->setLinePowerScreensaverDelay(*reinterpret_cast<int*>(_v)); break;
        case 9: _t->setLinePowerScreenBlackDelay(*reinterpret_cast<int*>(_v)); break;
        case 10: _t->setLinePowerSleepDelay(*reinterpret_cast<int*>(_v)); break;
        case 11: _t->setLinePowerLockDelay(*reinterpret_cast<int*>(_v)); break;
        case 12: _t->setBatteryScreensaverDelay(*reinterpret_cast<int*>(_v)); break;
        case 13: _t->setBatteryScreenBlackDelay(*reinterpret_cast<int*>(_v)); break;
        case 14: _t->setBatterySleepDelay(*reinterpret_cast<int*>(_v)); break;
        case 15: _t->setBatteryLockDelay(*reinterpret_cast<int*>(_v)); break;
        case 16: _t->setScreenBlackLock(*reinterpret_cast<bool*>(_v)); break;
        case 17: _t->setSleepLock(*reinterpret_cast<bool*>(_v)); break;
        case 18: _t->setLinePowerLidClosedAction(*reinterpret_cast<int*>(_v)); break;
        case 19: _t->setBatteryLidClosedAction(*reinterpret_cast<int*>(_v)); break;
        case 20: _t->setLinePowerPressPowerBtnAction(*reinterpret_cast<int*>(_v)); break;
        case 21: _t->setBatteryPressPowerBtnAction(*reinterpret_cast<int*>(_v)); break;
        case 22: _t->setLowPowerNotifyEnable(*reinterpret_cast<bool*>(_v)); break;
        case 23: _t->setLowPowerNotifyThreshold(*reinterpret_cast<int*>(_v)); break;
        case 24: _t->setLowPowerAutoSleepThreshold(*reinterpret_cast<int*>(_v)); break;
        case 25: _t->setLowPowerAction(*reinterpret_cast<int*>(_v)); break;
        case 26: _t->setAmbientLightAdjustBrightness(*reinterpret_cast<bool*>(_v)); break;
        case 27: _t->setScheduledShutdownState(*reinterpret_cast<bool*>(_v)); break;
        case 28: _t->setShutdownTime(*reinterpret_cast<QString*>(_v)); break;
        case 29: _t->setShutdownRepetition(*reinterpret_cast<int*>(_v)); break;
        case 30: _t->setCustomShutdownWeekDays(*reinterpret_cast<QByteArray*>(_v)); break;
        default: break;
        }
    }
}

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

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

int PowerManager::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 < 107)
            qt_static_metacall(this, _c, _id, _a);
        _id -= 107;
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        if (_id < 107)
            *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType();
        _id -= 107;
    }
    if (_c == QMetaObject::ReadProperty || _c == QMetaObject::WriteProperty
            || _c == QMetaObject::ResetProperty || _c == QMetaObject::BindableProperty
            || _c == QMetaObject::RegisterPropertyMetaType) {
        qt_static_metacall(this, _c, _id, _a);
        _id -= 31;
    }
    return _id;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SIGNAL 30
void PowerManager::customShutdownWeekDaysChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 30, nullptr);
}
QT_WARNING_POP
