/****************************************************************************
** Meta object code from reading C++ file 'powerdevilcore.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 "../../../../powerdevil-6.7.3/daemon/powerdevilcore.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 'powerdevilcore.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_ZN10PowerDevil4CoreE_t {};
} // unnamed namespace

template <> constexpr inline auto PowerDevil::Core::qt_create_metaobjectdata<qt_meta_tag_ZN10PowerDevil4CoreE_t>()
{
    namespace QMC = QtMocConstants;
    QtMocHelpers::StringRefStorage qt_stringData {
        "PowerDevil::Core",
        "D-Bus Interface",
        "org.kde.Solid.PowerManagement",
        "coreReady",
        "",
        "profileChanged",
        "newProfile",
        "configurationReloaded",
        "batteryRemainingTimeChanged",
        "time",
        "smoothedBatteryRemainingTimeChanged",
        "lidClosedChanged",
        "closed",
        "batteryConservationModeChanged",
        "enabled",
        "chargeStartThresholdChanged",
        "threshold",
        "chargeStopThresholdChanged",
        "supportedActionsChanged",
        "loadCore",
        "backendCapabilities",
        "refreshStatus",
        "reparseConfiguration",
        "onControllersReady",
        "refreshActions",
        "currentProfile",
        "loadProfile",
        "force",
        "batteryRemainingTime",
        "smoothedBatteryRemainingTime",
        "isLidClosed",
        "isLidPresent",
        "isActionSupported",
        "actionName",
        "hasDualGpu",
        "isBatteryConservationModeEnabled",
        "chargeStartThreshold",
        "chargeStopThreshold",
        "scheduleWakeup",
        "service",
        "QDBusObjectPath",
        "path",
        "timeout",
        "wakeup",
        "clearWakeup",
        "cookie",
        "onAcAdapterStateChanged",
        "BatteryController::AcAdapterState",
        "onBatteryChargePercentChanged",
        "onBatteryChargeStateChanged",
        "onBatteryRemainingTimeChanged",
        "onSmoothedBatteryRemainingTimeChanged",
        "onKIdleTimeoutReached",
        "onResumingFromIdle",
        "onDeviceAdded",
        "udi",
        "onDeviceRemoved",
        "onCriticalBatteryTimerExpired",
        "onNotificationTimeout",
        "onServiceRegistered",
        "onLidClosedChanged",
        "onAboutToSuspend",
        "resetAndScheduleNextWakeup",
        "timerfdEventHandler",
        "onScreenLockerActiveChanged",
        "active",
        "onResumeFromSuspend",
        "ChargeNotificationFlags",
        "ChargeNotificationFlag",
        "None",
        "NotifyWhenAcPluggedIn"
    };

    QtMocHelpers::UintData qt_methods {
        // Signal 'coreReady'
        QtMocHelpers::SignalData<void()>(3, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'profileChanged'
        QtMocHelpers::SignalData<void(const QString &)>(5, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::QString, 6 },
        }}),
        // Signal 'configurationReloaded'
        QtMocHelpers::SignalData<void()>(7, 4, QMC::AccessPublic, QMetaType::Void),
        // Signal 'batteryRemainingTimeChanged'
        QtMocHelpers::SignalData<void(qulonglong)>(8, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 9 },
        }}),
        // Signal 'smoothedBatteryRemainingTimeChanged'
        QtMocHelpers::SignalData<void(qulonglong)>(10, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::ULongLong, 9 },
        }}),
        // Signal 'lidClosedChanged'
        QtMocHelpers::SignalData<void(bool)>(11, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Signal 'batteryConservationModeChanged'
        QtMocHelpers::SignalData<void(bool)>(13, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 14 },
        }}),
        // Signal 'chargeStartThresholdChanged'
        QtMocHelpers::SignalData<void(int)>(15, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Signal 'chargeStopThresholdChanged'
        QtMocHelpers::SignalData<void(int)>(17, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 16 },
        }}),
        // Signal 'supportedActionsChanged'
        QtMocHelpers::SignalData<void()>(18, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'loadCore'
        QtMocHelpers::SlotData<void()>(19, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'backendCapabilities'
        QtMocHelpers::SlotData<uint()>(20, 4, QMC::AccessPublic, QMetaType::UInt),
        // Slot 'refreshStatus'
        QtMocHelpers::SlotData<void()>(21, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'reparseConfiguration'
        QtMocHelpers::SlotData<void()>(22, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'onControllersReady'
        QtMocHelpers::SlotData<void()>(23, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'refreshActions'
        QtMocHelpers::SlotData<void()>(24, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'currentProfile'
        QtMocHelpers::SlotData<QString() const>(25, 4, QMC::AccessPublic, QMetaType::QString),
        // Slot 'loadProfile'
        QtMocHelpers::SlotData<void(bool)>(26, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Bool, 27 },
        }}),
        // Slot 'loadProfile'
        QtMocHelpers::SlotData<void()>(26, 4, QMC::AccessPublic | QMC::MethodCloned, QMetaType::Void),
        // Slot 'batteryRemainingTime'
        QtMocHelpers::SlotData<qulonglong() const>(28, 4, QMC::AccessPublic, QMetaType::ULongLong),
        // Slot 'smoothedBatteryRemainingTime'
        QtMocHelpers::SlotData<qulonglong() const>(29, 4, QMC::AccessPublic, QMetaType::ULongLong),
        // Slot 'isLidClosed'
        QtMocHelpers::SlotData<bool() const>(30, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isLidPresent'
        QtMocHelpers::SlotData<bool() const>(31, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isActionSupported'
        QtMocHelpers::SlotData<bool(const QString &)>(32, 4, QMC::AccessPublic, QMetaType::Bool, {{
            { QMetaType::QString, 33 },
        }}),
        // Slot 'hasDualGpu'
        QtMocHelpers::SlotData<bool() const>(34, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'isBatteryConservationModeEnabled'
        QtMocHelpers::SlotData<bool() const>(35, 4, QMC::AccessPublic, QMetaType::Bool),
        // Slot 'chargeStartThreshold'
        QtMocHelpers::SlotData<int() const>(36, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'chargeStopThreshold'
        QtMocHelpers::SlotData<int() const>(37, 4, QMC::AccessPublic, QMetaType::Int),
        // Slot 'scheduleWakeup'
        QtMocHelpers::SlotData<uint(const QString &, const QDBusObjectPath &, qint64)>(38, 4, QMC::AccessPublic, QMetaType::UInt, {{
            { QMetaType::QString, 39 }, { 0x80000000 | 40, 41 }, { QMetaType::LongLong, 42 },
        }}),
        // Slot 'wakeup'
        QtMocHelpers::SlotData<void()>(43, 4, QMC::AccessPublic, QMetaType::Void),
        // Slot 'clearWakeup'
        QtMocHelpers::SlotData<void(int)>(44, 4, QMC::AccessPublic, QMetaType::Void, {{
            { QMetaType::Int, 45 },
        }}),
        // Slot 'onAcAdapterStateChanged'
        QtMocHelpers::SlotData<void(BatteryController::AcAdapterState)>(46, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { 0x80000000 | 47, 4 },
        }}),
        // Slot 'onBatteryChargePercentChanged'
        QtMocHelpers::SlotData<void(int, const QString &)>(48, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 4 }, { QMetaType::QString, 4 },
        }}),
        // Slot 'onBatteryChargeStateChanged'
        QtMocHelpers::SlotData<void(int, const QString &)>(49, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 4 }, { QMetaType::QString, 4 },
        }}),
        // Slot 'onBatteryRemainingTimeChanged'
        QtMocHelpers::SlotData<void(qulonglong)>(50, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::ULongLong, 4 },
        }}),
        // Slot 'onSmoothedBatteryRemainingTimeChanged'
        QtMocHelpers::SlotData<void(qulonglong)>(51, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::ULongLong, 4 },
        }}),
        // Slot 'onKIdleTimeoutReached'
        QtMocHelpers::SlotData<void(int, int)>(52, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Int, 4 }, { QMetaType::Int, 4 },
        }}),
        // Slot 'onResumingFromIdle'
        QtMocHelpers::SlotData<void()>(53, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onDeviceAdded'
        QtMocHelpers::SlotData<void(const QString &)>(54, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 55 },
        }}),
        // Slot 'onDeviceRemoved'
        QtMocHelpers::SlotData<void(const QString &)>(56, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 55 },
        }}),
        // Slot 'onCriticalBatteryTimerExpired'
        QtMocHelpers::SlotData<void()>(57, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onNotificationTimeout'
        QtMocHelpers::SlotData<void()>(58, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onServiceRegistered'
        QtMocHelpers::SlotData<void(const QString &)>(59, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::QString, 39 },
        }}),
        // Slot 'onLidClosedChanged'
        QtMocHelpers::SlotData<void(bool)>(60, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 12 },
        }}),
        // Slot 'onAboutToSuspend'
        QtMocHelpers::SlotData<void()>(61, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'resetAndScheduleNextWakeup'
        QtMocHelpers::SlotData<void()>(62, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'timerfdEventHandler'
        QtMocHelpers::SlotData<void()>(63, 4, QMC::AccessPrivate, QMetaType::Void),
        // Slot 'onScreenLockerActiveChanged'
        QtMocHelpers::SlotData<void(bool)>(64, 4, QMC::AccessPrivate, QMetaType::Void, {{
            { QMetaType::Bool, 65 },
        }}),
        // Slot 'onResumeFromSuspend'
        QtMocHelpers::SlotData<void()>(66, 4, QMC::AccessPrivate, QMetaType::Void),
    };
    QtMocHelpers::UintData qt_properties {
    };
    QtMocHelpers::UintData qt_enums {
        // flag 'ChargeNotificationFlags'
        QtMocHelpers::EnumData<ChargeNotificationFlags>(67, 68, QMC::EnumIsFlag | QMC::EnumIsScoped).add({
            {   69, ChargeNotificationFlag::None },
            {   70, ChargeNotificationFlag::NotifyWhenAcPluggedIn },
        }),
    };
    QtMocHelpers::UintData qt_constructors {};
    QtMocHelpers::ClassInfos qt_classinfo({
            {    1,    2 },
    });
    return QtMocHelpers::metaObjectData<Core, qt_meta_tag_ZN10PowerDevil4CoreE_t>(QMC::MetaObjectFlag{}, qt_stringData,
            qt_methods, qt_properties, qt_enums, qt_constructors, qt_classinfo);
}
Q_CONSTINIT const QMetaObject PowerDevil::Core::staticMetaObject = { {
    QMetaObject::SuperData::link<QObject::staticMetaObject>(),
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10PowerDevil4CoreE_t>.stringdata,
    qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10PowerDevil4CoreE_t>.data,
    qt_static_metacall,
    nullptr,
    qt_staticMetaObjectRelocatingContent<qt_meta_tag_ZN10PowerDevil4CoreE_t>.metaTypes,
    nullptr
} };

void PowerDevil::Core::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
    auto *_t = static_cast<Core *>(_o);
    if (_c == QMetaObject::InvokeMetaMethod) {
        switch (_id) {
        case 0: _t->coreReady(); break;
        case 1: _t->profileChanged((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 2: _t->configurationReloaded(); break;
        case 3: _t->batteryRemainingTimeChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 4: _t->smoothedBatteryRemainingTimeChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 5: _t->lidClosedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 6: _t->batteryConservationModeChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 7: _t->chargeStartThresholdChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 8: _t->chargeStopThresholdChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 9: _t->supportedActionsChanged(); break;
        case 10: _t->loadCore(); break;
        case 11: { uint _r = _t->backendCapabilities();
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 12: _t->refreshStatus(); break;
        case 13: _t->reparseConfiguration(); break;
        case 14: _t->onControllersReady(); break;
        case 15: _t->refreshActions(); break;
        case 16: { QString _r = _t->currentProfile();
            if (_a[0]) *reinterpret_cast<QString*>(_a[0]) = std::move(_r); }  break;
        case 17: _t->loadProfile((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 18: _t->loadProfile(); break;
        case 19: { qulonglong _r = _t->batteryRemainingTime();
            if (_a[0]) *reinterpret_cast<qulonglong*>(_a[0]) = std::move(_r); }  break;
        case 20: { qulonglong _r = _t->smoothedBatteryRemainingTime();
            if (_a[0]) *reinterpret_cast<qulonglong*>(_a[0]) = std::move(_r); }  break;
        case 21: { bool _r = _t->isLidClosed();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 22: { bool _r = _t->isLidPresent();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 23: { bool _r = _t->isActionSupported((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])));
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 24: { bool _r = _t->hasDualGpu();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 25: { bool _r = _t->isBatteryConservationModeEnabled();
            if (_a[0]) *reinterpret_cast<bool*>(_a[0]) = std::move(_r); }  break;
        case 26: { int _r = _t->chargeStartThreshold();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 27: { int _r = _t->chargeStopThreshold();
            if (_a[0]) *reinterpret_cast<int*>(_a[0]) = std::move(_r); }  break;
        case 28: { uint _r = _t->scheduleWakeup((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QDBusObjectPath>>(_a[2])),(*reinterpret_cast<std::add_pointer_t<qint64>>(_a[3])));
            if (_a[0]) *reinterpret_cast<uint*>(_a[0]) = std::move(_r); }  break;
        case 29: _t->wakeup(); break;
        case 30: _t->clearWakeup((*reinterpret_cast<std::add_pointer_t<int>>(_a[1]))); break;
        case 31: _t->onAcAdapterStateChanged((*reinterpret_cast<std::add_pointer_t<BatteryController::AcAdapterState>>(_a[1]))); break;
        case 32: _t->onBatteryChargePercentChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 33: _t->onBatteryChargeStateChanged((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<QString>>(_a[2]))); break;
        case 34: _t->onBatteryRemainingTimeChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 35: _t->onSmoothedBatteryRemainingTimeChanged((*reinterpret_cast<std::add_pointer_t<qulonglong>>(_a[1]))); break;
        case 36: _t->onKIdleTimeoutReached((*reinterpret_cast<std::add_pointer_t<int>>(_a[1])),(*reinterpret_cast<std::add_pointer_t<int>>(_a[2]))); break;
        case 37: _t->onResumingFromIdle(); break;
        case 38: _t->onDeviceAdded((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 39: _t->onDeviceRemoved((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 40: _t->onCriticalBatteryTimerExpired(); break;
        case 41: _t->onNotificationTimeout(); break;
        case 42: _t->onServiceRegistered((*reinterpret_cast<std::add_pointer_t<QString>>(_a[1]))); break;
        case 43: _t->onLidClosedChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 44: _t->onAboutToSuspend(); break;
        case 45: _t->resetAndScheduleNextWakeup(); break;
        case 46: _t->timerfdEventHandler(); break;
        case 47: _t->onScreenLockerActiveChanged((*reinterpret_cast<std::add_pointer_t<bool>>(_a[1]))); break;
        case 48: _t->onResumeFromSuspend(); break;
        default: ;
        }
    }
    if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
        switch (_id) {
        default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
        case 28:
            switch (*reinterpret_cast<int*>(_a[1])) {
            default: *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType(); break;
            case 1:
                *reinterpret_cast<QMetaType *>(_a[0]) = QMetaType::fromType< QDBusObjectPath >(); break;
            }
            break;
        }
    }
    if (_c == QMetaObject::IndexOfMethod) {
        if (QtMocHelpers::indexOfMethod<void (Core::*)()>(_a, &Core::coreReady, 0))
            return;
        if (QtMocHelpers::indexOfMethod<void (Core::*)(const QString & )>(_a, &Core::profileChanged, 1))
            return;
        if (QtMocHelpers::indexOfMethod<void (Core::*)()>(_a, &Core::configurationReloaded, 2))
            return;
        if (QtMocHelpers::indexOfMethod<void (Core::*)(qulonglong )>(_a, &Core::batteryRemainingTimeChanged, 3))
            return;
        if (QtMocHelpers::indexOfMethod<void (Core::*)(qulonglong )>(_a, &Core::smoothedBatteryRemainingTimeChanged, 4))
            return;
        if (QtMocHelpers::indexOfMethod<void (Core::*)(bool )>(_a, &Core::lidClosedChanged, 5))
            return;
        if (QtMocHelpers::indexOfMethod<void (Core::*)(bool )>(_a, &Core::batteryConservationModeChanged, 6))
            return;
        if (QtMocHelpers::indexOfMethod<void (Core::*)(int )>(_a, &Core::chargeStartThresholdChanged, 7))
            return;
        if (QtMocHelpers::indexOfMethod<void (Core::*)(int )>(_a, &Core::chargeStopThresholdChanged, 8))
            return;
        if (QtMocHelpers::indexOfMethod<void (Core::*)()>(_a, &Core::supportedActionsChanged, 9))
            return;
    }
}

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

void *PowerDevil::Core::qt_metacast(const char *_clname)
{
    if (!_clname) return nullptr;
    if (!strcmp(_clname, qt_staticMetaObjectStaticContent<qt_meta_tag_ZN10PowerDevil4CoreE_t>.strings))
        return static_cast<void*>(this);
    if (!strcmp(_clname, "QDBusContext"))
        return static_cast< QDBusContext*>(this);
    return QObject::qt_metacast(_clname);
}

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

// SIGNAL 0
void PowerDevil::Core::coreReady()
{
    QMetaObject::activate(this, &staticMetaObject, 0, nullptr);
}

// SIGNAL 1
void PowerDevil::Core::profileChanged(const QString & _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 1, nullptr, _t1);
}

// SIGNAL 2
void PowerDevil::Core::configurationReloaded()
{
    QMetaObject::activate(this, &staticMetaObject, 2, nullptr);
}

// SIGNAL 3
void PowerDevil::Core::batteryRemainingTimeChanged(qulonglong _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 3, nullptr, _t1);
}

// SIGNAL 4
void PowerDevil::Core::smoothedBatteryRemainingTimeChanged(qulonglong _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 4, nullptr, _t1);
}

// SIGNAL 5
void PowerDevil::Core::lidClosedChanged(bool _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 5, nullptr, _t1);
}

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

// SIGNAL 7
void PowerDevil::Core::chargeStartThresholdChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 7, nullptr, _t1);
}

// SIGNAL 8
void PowerDevil::Core::chargeStopThresholdChanged(int _t1)
{
    QMetaObject::activate<void>(this, &staticMetaObject, 8, nullptr, _t1);
}

// SIGNAL 9
void PowerDevil::Core::supportedActionsChanged()
{
    QMetaObject::activate(this, &staticMetaObject, 9, nullptr);
}
QT_WARNING_POP
