
// Workaround to access protected functions
#ifndef protected
#  define protected public
#endif

// default includes
#include <shiboken.h>
#include <sbkpep.h>
#include <sbkpepbuffer.h>

#define PYSIDE6_COMOPT_COMPRESS 1

#ifndef QT_NO_VERSION_TAGGING
#  define QT_NO_VERSION_TAGGING
#endif
#include <QtCore/QDebug>
#include <pysideqenum.h>
#include <pysideutils.h>
#include <feature_select.h>
QT_WARNING_DISABLE_DEPRECATED


// module include
#include "kcalendarcore_python.h"

// main header
#include "kcalendarcore_alarm_wrapper.h"

// Wrappers providing overrides
#include "kcalendarcore_memorycalendar_wrapper.h"
#include "kcalendarcore_customproperties_wrapper.h"

// Argument includes
#include <QList>
#include <QString>
#include <QStringList>
#include <alarm.h>
#include <duration.h>
#include <incidence.h>
#include <person.h>
#include <qdatetime.h>
#include <qtimezone.h>

#include <cctype>
#include <cstring>
#include <iterator>
#include <type_traits>
#include <typeinfo>

using namespace KCalendarCore;

extern "C" {
static PyTypeObject *Sbk_KCalendarCore_Alarm_TypeF(void)
{
    return SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX].type;
}
} // extern "C"

// Native ---------------------------------------------------------

void AlarmWrapper::resetPyMethodCache()
{
    std::fill(m_PyMethodCache.begin(), m_PyMethodCache.end(), nullptr);
}

AlarmWrapper::AlarmWrapper(::KCalendarCore::Incidence * parent) : KCalendarCore::Alarm(parent)
{
}

void AlarmWrapper::customPropertyUpdate()
{
    static const char *funcName = "customPropertyUpdate";
    static PyObject *nameCache[2] = {};
    Shiboken::GilState gil(false);
    Shiboken::AutoDecRef pyOverride(Sbk_GetPyOverride(this, Sbk_KCalendarCore_Alarm_TypeF(), gil, funcName, m_PyMethodCache[0], nameCache));
    if (pyOverride.isNull()) {
        return this->::KCalendarCore::CustomProperties::customPropertyUpdate();
    }
    CustomPropertiesWrapper::sbk_o_customPropertyUpdate("Alarm", funcName, gil, pyOverride);
}

void AlarmWrapper::customPropertyUpdated()
{
    static const char *funcName = "customPropertyUpdated";
    static PyObject *nameCache[2] = {};
    Shiboken::GilState gil(false);
    Shiboken::AutoDecRef pyOverride(Sbk_GetPyOverride(this, Sbk_KCalendarCore_Alarm_TypeF(), gil, funcName, m_PyMethodCache[1], nameCache));
    if (pyOverride.isNull()) {
        return this->::KCalendarCore::Alarm::customPropertyUpdated();
    }
    CustomPropertiesWrapper::sbk_o_customPropertyUpdate("Alarm", funcName, gil, pyOverride);
}

void AlarmWrapper::virtual_hook(int id, void * data)
{
    static const char *funcName = "virtual_hook";
    static PyObject *nameCache[2] = {};
    Shiboken::GilState gil(false);
    Shiboken::AutoDecRef pyOverride(Sbk_GetPyOverride(this, Sbk_KCalendarCore_Alarm_TypeF(), gil, funcName, m_PyMethodCache[2], nameCache));
    if (pyOverride.isNull()) {
        return this->::KCalendarCore::Alarm::virtual_hook(id, data);
    }
    MemoryCalendarWrapper::sbk_o_virtual_hook("Alarm", funcName, gil, pyOverride, id, data);
}

AlarmWrapper::~AlarmWrapper()
{
    auto *wrapper = Shiboken::BindingManager::instance().retrieveWrapper(this, Sbk_KCalendarCore_Alarm_TypeF());
    Shiboken::Object::destroy(wrapper, this);
}

// Target ---------------------------------------------------------

extern "C" {
static int
Sbk_KCalendarCore_Alarm_Init(PyObject *self, PyObject *args, [[maybe_unused]] PyObject *kwds)
{
    auto *sbkSelf = reinterpret_cast<SbkObject *>(self);
    PySide::Feature::Select(self);
    if (Shiboken::Object::isUserType(self) && !Shiboken::ObjectType::canCallConstructor(self->ob_type, Shiboken::SbkType< ::KCalendarCore::Alarm >()))
        return -1;

    AlarmWrapper *cptr{};
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp[1];
    const Py_ssize_t numArgs = PyTuple_Size(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {nullptr};

    // invalid argument lengths

    if (PyArg_UnpackTuple(args, "Alarm", 1, 1, &(pyArgs[0])) == 0)
        return -1;


    // Overloaded function decisor
    // 0: Alarm::Alarm(KCalendarCore::Incidence*)
    // 1: Alarm::Alarm(const KCalendarCore::Alarm&)
    if (numArgs == 1
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), (pyArgs[0])))) {
        overloadId = 1; // Alarm::Alarm(const KCalendarCore::Alarm&)
    } else if (numArgs == 1
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppPointerConversion(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Incidence_IDX]), (pyArgs[0])))) {
        overloadId = 0; // Alarm::Alarm(KCalendarCore::Incidence*)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments_MinusOne(args, "__init__", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);


    // PyMI support
    Shiboken::callInheritedInit(self, args, kwds, SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);
    if (Shiboken::Errors::occurred() != nullptr)
        return -1;

    // Call function/method
    switch (overloadId) {
        case 0: // Alarm(KCalendarCore::Incidence *parent)
        {
            if (!Shiboken::Object::isValid(pyArgs[0]))
                return -1;
            ::KCalendarCore::Incidence *cppArg0;
            pythonToCpp[0](pyArgs[0], &cppArg0);

            if (Shiboken::Errors::occurred() == nullptr) {
                // Alarm::Alarm(KCalendarCore::Incidence*)
                cptr = new AlarmWrapper(cppArg0);
            }
            break;
        }
        case 1: // Alarm(const KCalendarCore::Alarm &other)
        {
            if (!Shiboken::Object::isValid(pyArgs[0]))
                return -1;
            ::KCalendarCore::Alarm *cppArg0;
            pythonToCpp[0](pyArgs[0], &cppArg0);

            if (Shiboken::Errors::occurred() == nullptr) {
                // Alarm::Alarm(const KCalendarCore::Alarm&)
                cptr = new AlarmWrapper(*cppArg0);
            }
            break;
        }
    }

    if (Shiboken::Errors::occurred() != nullptr || !Shiboken::Object::setCppPointer(sbkSelf, Shiboken::SbkType< KCalendarCore::Alarm >(), cptr)) {
        delete cptr;
        return -1;
    }
    if (cptr == nullptr)
        return Shiboken::returnWrongArguments_MinusOne(args, "__init__", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    Shiboken::Object::setValidCpp(sbkSelf, true);
    Shiboken::Object::setHasCppWrapper(sbkSelf, true);
    Shiboken::BindingManager::instance().registerWrapper(sbkSelf, cptr);


    return 1;
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_addMailAddress(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::addMailAddress(const KCalendarCore::Person&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Person_IDX]), (pyArg)))) {
        overloadId = 0; // Alarm::addMailAddress(const KCalendarCore::Person&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "addMailAddress", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArg))
            return {};
        ::KCalendarCore::Person *cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::addMailAddress(const KCalendarCore::Person&)
            cppSelf->addMailAddress(*cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_addMailAttachment(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::addMailAttachment(const QString&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArg)))) {
        overloadId = 0; // Alarm::addMailAttachment(const QString&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "addMailAttachment", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        ::QString cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::addMailAttachment(const QString&)
            cppSelf->addMailAttachment(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_audioFile(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::audioFile()const->QString
        QString cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->audioFile();
        pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_customPropertyUpdated(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // CustomProperties::customPropertyUpdated()
        Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject *>(self))
            ? cppSelf->::KCalendarCore::Alarm::customPropertyUpdated()
            : cppSelf->customPropertyUpdated();
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_duration(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::duration()const->KCalendarCore::Duration
        KCalendarCore::Duration cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->duration();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Duration_IDX]), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_enabled(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::enabled()const->bool
        bool cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->enabled();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_endOffset(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::endOffset()const->KCalendarCore::Duration
        KCalendarCore::Duration cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->endOffset();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Duration_IDX]), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_endTime(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::endTime()const->QDateTime
        QDateTime cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->endTime();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDateTime_IDX]), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_hasEndOffset(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::hasEndOffset()const->bool
        bool cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->hasEndOffset();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_hasLocationRadius(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::hasLocationRadius()const->bool
        bool cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->hasLocationRadius();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_hasStartOffset(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::hasStartOffset()const->bool
        bool cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->hasStartOffset();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_hasTime(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::hasTime()const->bool
        bool cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->hasTime();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_locationRadius(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::locationRadius()const->int
        int cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->locationRadius();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_mailAddresses(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::mailAddresses()const->QList<KCalendarCore::Person>
        QList<KCalendarCore::Person> cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->mailAddresses();
        pyResult = Shiboken::Conversions::copyToPython(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Person_IDX], &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_mailAttachments(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::mailAttachments()const->QStringList
        QStringList cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->mailAttachments();
        pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QStringList_IDX], &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_mailSubject(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::mailSubject()const->QString
        QString cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->mailSubject();
        pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_mailText(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::mailText()const->QString
        QString cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->mailText();
        pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_nextRepetition(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::nextRepetition(const QDateTime&)const->QDateTime
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDateTime_IDX]), (pyArg)))) {
        overloadId = 0; // Alarm::nextRepetition(const QDateTime&)const->QDateTime
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "nextRepetition", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArg))
            return {};
        ::QDateTime cppArg0_local;
        ::QDateTime *cppArg0 = &cppArg0_local;
        if (pythonToCpp.isValue())
            pythonToCpp(pyArg, &cppArg0_local);
        else
            pythonToCpp(pyArg, &cppArg0);


        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::nextRepetition(const QDateTime&)const->QDateTime
            QDateTime cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->nextRepetition(*cppArg0);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDateTime_IDX]), &cppResult);
        }
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_nextTime(PyObject *self, PyObject *args, [[maybe_unused]] PyObject *kwds)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp[2];
    const Py_ssize_t numArgs = PyTuple_Size(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {nullptr, nullptr};

    // invalid argument lengths
    errInfo.reset(Shiboken::checkInvalidArgumentCount(numArgs, 1, 2));
    if (!errInfo.isNull())
        return Shiboken::returnWrongArguments(args, "nextTime", errInfo, SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    if (PyArg_ParseTuple(args, "|OO:nextTime", &(pyArgs[0]), &(pyArgs[1])) == 0)
        return {};


    // Overloaded function decisor
    // 0: Alarm::nextTime(const QDateTime&,bool=)const->QDateTime
    if (numArgs >= 1
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDateTime_IDX]), (pyArgs[0])))) {
        if (numArgs == 1) {
            overloadId = 0; // nextTime(QDateTime,bool)const
        } else if (numArgs >= 2
            && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), (pyArgs[1])))) {
            overloadId = 0; // Alarm::nextTime(const QDateTime&,bool=)const->QDateTime
        }
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(args, "nextTime", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (kwds != nullptr && PyDict_Size(kwds) > 0) {
            static const Shiboken::ArgumentNameIndexMapping mapping[1] = {{"ignoreRepetitions", 1}};
            if (!Shiboken::parseKeywordArguments(kwds, mapping, 1, errInfo, pyArgs)
                || (pyArgs[1] != nullptr && !((pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), (pyArgs[1])))))) {
                Py_XINCREF(errInfo.object());
                return Shiboken::returnWrongArguments(args, "nextTime", errInfo, SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);
            }
        }
        if (!Shiboken::Object::isValid(pyArgs[0]))
            return {};
        ::QDateTime cppArg0_local;
        ::QDateTime *cppArg0 = &cppArg0_local;
        if (pythonToCpp[0].isValue())
            pythonToCpp[0](pyArgs[0], &cppArg0_local);
        else
            pythonToCpp[0](pyArgs[0], &cppArg0);

        bool cppArg1 = false;
        if (pythonToCpp[1])
            pythonToCpp[1](pyArgs[1], &cppArg1);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::nextTime(const QDateTime&,bool=)const->QDateTime
            QDateTime cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->nextTime(*cppArg0, cppArg1);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDateTime_IDX]), &cppResult);
        }
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_parentUid(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::parentUid()const->QString
        QString cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->parentUid();
        pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_previousRepetition(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::previousRepetition(const QDateTime&)const->QDateTime
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDateTime_IDX]), (pyArg)))) {
        overloadId = 0; // Alarm::previousRepetition(const QDateTime&)const->QDateTime
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "previousRepetition", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArg))
            return {};
        ::QDateTime cppArg0_local;
        ::QDateTime *cppArg0 = &cppArg0_local;
        if (pythonToCpp.isValue())
            pythonToCpp(pyArg, &cppArg0_local);
        else
            pythonToCpp(pyArg, &cppArg0);


        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::previousRepetition(const QDateTime&)const->QDateTime
            QDateTime cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->previousRepetition(*cppArg0);
            pyResult = Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDateTime_IDX]), &cppResult);
        }
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_programArguments(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::programArguments()const->QString
        QString cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->programArguments();
        pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_programFile(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::programFile()const->QString
        QString cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->programFile();
        pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_repeatCount(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::repeatCount()const->int
        int cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->repeatCount();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setAudioAlarm(PyObject *self, PyObject *args, [[maybe_unused]] PyObject *kwds)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp[1];
    const Py_ssize_t numArgs = PyTuple_Size(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {nullptr};

    // invalid argument lengths
    errInfo.reset(Shiboken::checkInvalidArgumentCount(numArgs, 0, 1));
    if (!errInfo.isNull())
        return Shiboken::returnWrongArguments(args, "setAudioAlarm", errInfo, SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    if (PyArg_ParseTuple(args, "|O:setAudioAlarm", &(pyArgs[0])) == 0)
        return {};


    // Overloaded function decisor
    // 0: Alarm::setAudioAlarm(const QString&=)
    if (numArgs == 0) {
        overloadId = 0; // setAudioAlarm(QString)
    } else if (numArgs >= 1
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArgs[0])))) {
        overloadId = 0; // Alarm::setAudioAlarm(const QString&=)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(args, "setAudioAlarm", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (kwds != nullptr && PyDict_Size(kwds) > 0) {
            static const Shiboken::ArgumentNameIndexMapping mapping[1] = {{"audioFile", 0}};
            if (!Shiboken::parseKeywordArguments(kwds, mapping, 1, errInfo, pyArgs)
                || (pyArgs[0] != nullptr && !((pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArgs[0])))))) {
                Py_XINCREF(errInfo.object());
                return Shiboken::returnWrongArguments(args, "setAudioAlarm", errInfo, SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);
            }
        }
        ::QString cppArg0 = QString();
        if (pythonToCpp[0])
            pythonToCpp[0](pyArgs[0], &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setAudioAlarm(const QString&=)
            cppSelf->setAudioAlarm(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setAudioFile(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setAudioFile(const QString&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArg)))) {
        overloadId = 0; // Alarm::setAudioFile(const QString&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setAudioFile", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        ::QString cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setAudioFile(const QString&)
            cppSelf->setAudioFile(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setDisplayAlarm(PyObject *self, PyObject *args, [[maybe_unused]] PyObject *kwds)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp[1];
    const Py_ssize_t numArgs = PyTuple_Size(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {nullptr};

    // invalid argument lengths
    errInfo.reset(Shiboken::checkInvalidArgumentCount(numArgs, 0, 1));
    if (!errInfo.isNull())
        return Shiboken::returnWrongArguments(args, "setDisplayAlarm", errInfo, SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    if (PyArg_ParseTuple(args, "|O:setDisplayAlarm", &(pyArgs[0])) == 0)
        return {};


    // Overloaded function decisor
    // 0: Alarm::setDisplayAlarm(const QString&=)
    if (numArgs == 0) {
        overloadId = 0; // setDisplayAlarm(QString)
    } else if (numArgs >= 1
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArgs[0])))) {
        overloadId = 0; // Alarm::setDisplayAlarm(const QString&=)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(args, "setDisplayAlarm", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (kwds != nullptr && PyDict_Size(kwds) > 0) {
            static const Shiboken::ArgumentNameIndexMapping mapping[1] = {{"text", 0}};
            if (!Shiboken::parseKeywordArguments(kwds, mapping, 1, errInfo, pyArgs)
                || (pyArgs[0] != nullptr && !((pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArgs[0])))))) {
                Py_XINCREF(errInfo.object());
                return Shiboken::returnWrongArguments(args, "setDisplayAlarm", errInfo, SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);
            }
        }
        ::QString cppArg0 = QString();
        if (pythonToCpp[0])
            pythonToCpp[0](pyArgs[0], &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setDisplayAlarm(const QString&=)
            cppSelf->setDisplayAlarm(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setEmailAlarm(PyObject *self, PyObject *args, [[maybe_unused]] PyObject *kwds)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp[4];
    const Py_ssize_t numArgs = PyTuple_Size(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {nullptr, nullptr, nullptr, nullptr};

    // invalid argument lengths
    errInfo.reset(Shiboken::checkInvalidArgumentCount(numArgs, 3, 4));
    if (!errInfo.isNull())
        return Shiboken::returnWrongArguments(args, "setEmailAlarm", errInfo, SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    if (PyArg_ParseTuple(args, "|OOOO:setEmailAlarm", &(pyArgs[0]), &(pyArgs[1]), &(pyArgs[2]), &(pyArgs[3])) == 0)
        return {};


    // Overloaded function decisor
    // 0: Alarm::setEmailAlarm(const QString&,const QString&,const QList<KCalendarCore::Person>&,const QStringList&=)
    if (numArgs >= 3
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArgs[0])))
        && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArgs[1])))
        && (pythonToCpp[2] = Shiboken::Conversions::pythonToCppConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Person_IDX], (pyArgs[2])))) {
        if (numArgs == 3) {
            overloadId = 0; // setEmailAlarm(QString,QString,QList<KCalendarCore::Person>,QStringList)
        } else if (numArgs >= 4
            && (pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QStringList_IDX], (pyArgs[3])))) {
            overloadId = 0; // Alarm::setEmailAlarm(const QString&,const QString&,const QList<KCalendarCore::Person>&,const QStringList&=)
        }
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(args, "setEmailAlarm", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (kwds != nullptr && PyDict_Size(kwds) > 0) {
            static const Shiboken::ArgumentNameIndexMapping mapping[1] = {{"attachments", 3}};
            if (!Shiboken::parseKeywordArguments(kwds, mapping, 1, errInfo, pyArgs)
                || (pyArgs[3] != nullptr && !((pythonToCpp[3] = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QStringList_IDX], (pyArgs[3])))))) {
                Py_XINCREF(errInfo.object());
                return Shiboken::returnWrongArguments(args, "setEmailAlarm", errInfo, SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);
            }
        }
        ::QString cppArg0;
        pythonToCpp[0](pyArgs[0], &cppArg0);
        ::QString cppArg1;
        pythonToCpp[1](pyArgs[1], &cppArg1);
        ::QList<KCalendarCore::Person> cppArg2;
        pythonToCpp[2](pyArgs[2], &cppArg2);
        ::QStringList cppArg3 = QStringList();
        if (pythonToCpp[3])
            pythonToCpp[3](pyArgs[3], &cppArg3);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setEmailAlarm(const QString&,const QString&,const QList<KCalendarCore::Person>&,const QStringList&=)
            cppSelf->setEmailAlarm(cppArg0, cppArg1, cppArg2, cppArg3);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setEnabled(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setEnabled(bool)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), (pyArg)))) {
        overloadId = 0; // Alarm::setEnabled(bool)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setEnabled", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        bool cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setEnabled(bool)
            cppSelf->setEnabled(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setEndOffset(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setEndOffset(const KCalendarCore::Duration&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Duration_IDX]), (pyArg)))) {
        overloadId = 0; // Alarm::setEndOffset(const KCalendarCore::Duration&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setEndOffset", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArg))
            return {};
        ::KCalendarCore::Duration cppArg0_local;
        ::KCalendarCore::Duration *cppArg0 = &cppArg0_local;
        if (pythonToCpp.isValue())
            pythonToCpp(pyArg, &cppArg0_local);
        else
            pythonToCpp(pyArg, &cppArg0);


        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setEndOffset(const KCalendarCore::Duration&)
            cppSelf->setEndOffset(*cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setHasLocationRadius(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setHasLocationRadius(bool)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), (pyArg)))) {
        overloadId = 0; // Alarm::setHasLocationRadius(bool)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setHasLocationRadius", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        bool cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setHasLocationRadius(bool)
            cppSelf->setHasLocationRadius(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setLocationRadius(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setLocationRadius(int)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArg)))) {
        overloadId = 0; // Alarm::setLocationRadius(int)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setLocationRadius", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        int cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setLocationRadius(int)
            cppSelf->setLocationRadius(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setMailAddress(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setMailAddress(const KCalendarCore::Person&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Person_IDX]), (pyArg)))) {
        overloadId = 0; // Alarm::setMailAddress(const KCalendarCore::Person&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setMailAddress", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArg))
            return {};
        ::KCalendarCore::Person *cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setMailAddress(const KCalendarCore::Person&)
            cppSelf->setMailAddress(*cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setMailAddresses(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setMailAddresses(const QList<KCalendarCore::Person>&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Person_IDX], (pyArg)))) {
        overloadId = 0; // Alarm::setMailAddresses(const QList<KCalendarCore::Person>&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setMailAddresses", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        ::QList<KCalendarCore::Person> cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setMailAddresses(const QList<KCalendarCore::Person>&)
            cppSelf->setMailAddresses(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setMailAttachment(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setMailAttachment(const QString&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArg)))) {
        overloadId = 0; // Alarm::setMailAttachment(const QString&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setMailAttachment", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        ::QString cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setMailAttachment(const QString&)
            cppSelf->setMailAttachment(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setMailAttachments(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setMailAttachments(const QStringList&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QStringList_IDX], (pyArg)))) {
        overloadId = 0; // Alarm::setMailAttachments(const QStringList&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setMailAttachments", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        ::QStringList cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setMailAttachments(const QStringList&)
            cppSelf->setMailAttachments(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setMailSubject(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setMailSubject(const QString&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArg)))) {
        overloadId = 0; // Alarm::setMailSubject(const QString&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setMailSubject", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        ::QString cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setMailSubject(const QString&)
            cppSelf->setMailSubject(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setMailText(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setMailText(const QString&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArg)))) {
        overloadId = 0; // Alarm::setMailText(const QString&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setMailText", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        ::QString cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setMailText(const QString&)
            cppSelf->setMailText(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setParent(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setParent(KCalendarCore::Incidence*)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppPointerConversion(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Incidence_IDX]), (pyArg)))) {
        overloadId = 0; // Alarm::setParent(KCalendarCore::Incidence*)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setParent", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArg))
            return {};
        ::KCalendarCore::Incidence *cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setParent(KCalendarCore::Incidence*)
            cppSelf->setParent(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setProcedureAlarm(PyObject *self, PyObject *args, [[maybe_unused]] PyObject *kwds)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp[2];
    const Py_ssize_t numArgs = PyTuple_Size(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {nullptr, nullptr};

    // invalid argument lengths
    errInfo.reset(Shiboken::checkInvalidArgumentCount(numArgs, 1, 2));
    if (!errInfo.isNull())
        return Shiboken::returnWrongArguments(args, "setProcedureAlarm", errInfo, SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    if (PyArg_ParseTuple(args, "|OO:setProcedureAlarm", &(pyArgs[0]), &(pyArgs[1])) == 0)
        return {};


    // Overloaded function decisor
    // 0: Alarm::setProcedureAlarm(const QString&,const QString&=)
    if (numArgs >= 1
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArgs[0])))) {
        if (numArgs == 1) {
            overloadId = 0; // setProcedureAlarm(QString,QString)
        } else if (numArgs >= 2
            && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArgs[1])))) {
            overloadId = 0; // Alarm::setProcedureAlarm(const QString&,const QString&=)
        }
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(args, "setProcedureAlarm", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (kwds != nullptr && PyDict_Size(kwds) > 0) {
            static const Shiboken::ArgumentNameIndexMapping mapping[1] = {{"arguments", 1}};
            if (!Shiboken::parseKeywordArguments(kwds, mapping, 1, errInfo, pyArgs)
                || (pyArgs[1] != nullptr && !((pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArgs[1])))))) {
                Py_XINCREF(errInfo.object());
                return Shiboken::returnWrongArguments(args, "setProcedureAlarm", errInfo, SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);
            }
        }
        ::QString cppArg0;
        pythonToCpp[0](pyArgs[0], &cppArg0);
        ::QString cppArg1 = QString();
        if (pythonToCpp[1])
            pythonToCpp[1](pyArgs[1], &cppArg1);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setProcedureAlarm(const QString&,const QString&=)
            cppSelf->setProcedureAlarm(cppArg0, cppArg1);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setProgramArguments(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setProgramArguments(const QString&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArg)))) {
        overloadId = 0; // Alarm::setProgramArguments(const QString&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setProgramArguments", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        ::QString cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setProgramArguments(const QString&)
            cppSelf->setProgramArguments(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setProgramFile(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setProgramFile(const QString&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArg)))) {
        overloadId = 0; // Alarm::setProgramFile(const QString&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setProgramFile", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        ::QString cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setProgramFile(const QString&)
            cppSelf->setProgramFile(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setRepeatCount(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setRepeatCount(int)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArg)))) {
        overloadId = 0; // Alarm::setRepeatCount(int)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setRepeatCount", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        int cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setRepeatCount(int)
            cppSelf->setRepeatCount(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setSnoozeTime(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setSnoozeTime(const KCalendarCore::Duration&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Duration_IDX]), (pyArg)))) {
        overloadId = 0; // Alarm::setSnoozeTime(const KCalendarCore::Duration&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setSnoozeTime", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArg))
            return {};
        ::KCalendarCore::Duration cppArg0_local;
        ::KCalendarCore::Duration *cppArg0 = &cppArg0_local;
        if (pythonToCpp.isValue())
            pythonToCpp(pyArg, &cppArg0_local);
        else
            pythonToCpp(pyArg, &cppArg0);


        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setSnoozeTime(const KCalendarCore::Duration&)
            cppSelf->setSnoozeTime(*cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setStartOffset(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setStartOffset(const KCalendarCore::Duration&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Duration_IDX]), (pyArg)))) {
        overloadId = 0; // Alarm::setStartOffset(const KCalendarCore::Duration&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setStartOffset", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArg))
            return {};
        ::KCalendarCore::Duration cppArg0_local;
        ::KCalendarCore::Duration *cppArg0 = &cppArg0_local;
        if (pythonToCpp.isValue())
            pythonToCpp(pyArg, &cppArg0_local);
        else
            pythonToCpp(pyArg, &cppArg0);


        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setStartOffset(const KCalendarCore::Duration&)
            cppSelf->setStartOffset(*cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setText(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setText(const QString&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], (pyArg)))) {
        overloadId = 0; // Alarm::setText(const QString&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setText", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        ::QString cppArg0;
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setText(const QString&)
            cppSelf->setText(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setTime(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setTime(const QDateTime&)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDateTime_IDX]), (pyArg)))) {
        overloadId = 0; // Alarm::setTime(const QDateTime&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setTime", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArg))
            return {};
        ::QDateTime cppArg0_local;
        ::QDateTime *cppArg0 = &cppArg0_local;
        if (pythonToCpp.isValue())
            pythonToCpp(pyArg, &cppArg0_local);
        else
            pythonToCpp(pyArg, &cppArg0);


        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setTime(const QDateTime&)
            cppSelf->setTime(*cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_setType(PyObject *self, PyObject *pyArg)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;

    // Overloaded function decisor
    // 0: Alarm::setType(KCalendarCore::Alarm::Type)
    if ((pythonToCpp = Shiboken::Conversions::pythonToCppConversion(Shiboken::Enum::getConverter(reinterpret_cast<SbkEnumType *>(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_Type_IDX]))), (pyArg)))) {
        overloadId = 0; // Alarm::setType(KCalendarCore::Alarm::Type)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(pyArg, "setType", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        ::KCalendarCore::Alarm::Type cppArg0{KCalendarCore::Alarm::Invalid};
        pythonToCpp(pyArg, &cppArg0);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::setType(KCalendarCore::Alarm::Type)
            cppSelf->setType(cppArg0);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_shiftTimes(PyObject *self, PyObject *args)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp[2];
    const Py_ssize_t numArgs = PyTuple_Size(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {nullptr, nullptr};

    // invalid argument lengths

    if (PyArg_UnpackTuple(args, "shiftTimes", 2, 2, &(pyArgs[0]), &(pyArgs[1])) == 0)
        return {};


    // Overloaded function decisor
    // 0: Alarm::shiftTimes(const QTimeZone&,const QTimeZone&)
    if (numArgs == 2
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QTimeZone_IDX]), (pyArgs[0])))
        && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QTimeZone_IDX]), (pyArgs[1])))) {
        overloadId = 0; // Alarm::shiftTimes(const QTimeZone&,const QTimeZone&)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(args, "shiftTimes", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        if (!Shiboken::Object::isValid(pyArgs[0]))
            return {};
        ::QTimeZone cppArg0_local;
        ::QTimeZone *cppArg0 = &cppArg0_local;
        if (pythonToCpp[0].isValue())
            pythonToCpp[0](pyArgs[0], &cppArg0_local);
        else
            pythonToCpp[0](pyArgs[0], &cppArg0);

        if (!Shiboken::Object::isValid(pyArgs[1]))
            return {};
        ::QTimeZone cppArg1_local;
        ::QTimeZone *cppArg1 = &cppArg1_local;
        if (pythonToCpp[1].isValue())
            pythonToCpp[1](pyArgs[1], &cppArg1_local);
        else
            pythonToCpp[1](pyArgs[1], &cppArg1);


        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::shiftTimes(const QTimeZone&,const QTimeZone&)
            cppSelf->shiftTimes(*cppArg0, *cppArg1);
        }
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_snoozeTime(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::snoozeTime()const->KCalendarCore::Duration
        KCalendarCore::Duration cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->snoozeTime();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Duration_IDX]), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_startOffset(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::startOffset()const->KCalendarCore::Duration
        KCalendarCore::Duration cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->startOffset();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Duration_IDX]), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_text(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::text()const->QString
        QString cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->text();
        pyResult = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_time(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::time()const->QDateTime
        QDateTime cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->time();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDateTime_IDX]), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_toggleAlarm(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::toggleAlarm()
        cppSelf->toggleAlarm();
    }

     return Sbk_ReturnFromPython_None();
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_type(PyObject *self)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    Shiboken::PythonContextMarker pcm;

    // Call function/method
    {

        // Alarm::type()const->KCalendarCore::Alarm::Type
        KCalendarCore::Alarm::Type cppResult = const_cast<const ::KCalendarCore::Alarm *>(cppSelf)->type();
        pyResult = Shiboken::Conversions::copyToPython(Shiboken::Enum::getConverter(reinterpret_cast<SbkEnumType *>(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_Type_IDX]))), &cppResult);
    }

    return Sbk_ReturnFromPython_Result(pyResult);
}

static PyObject *Sbk_KCalendarCore_AlarmFunc_virtual_hook(PyObject *self, PyObject *args)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto *cppSelf = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    Shiboken::AutoDecRef errInfo{};
    Shiboken::PythonContextMarker pcm;
    int overloadId = -1;
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp[2];
    const Py_ssize_t numArgs = PyTuple_Size(args);
    SBK_UNUSED(numArgs)
    PyObject *pyArgs[] = {nullptr, nullptr};

    // invalid argument lengths

    if (PyArg_UnpackTuple(args, "virtual_hook", 2, 2, &(pyArgs[0]), &(pyArgs[1])) == 0)
        return {};


    // Overloaded function decisor
    // 0: Alarm::virtual_hook(int,void*)
    if (numArgs == 2
        && (pythonToCpp[0] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArgs[0])))
        && (pythonToCpp[1] = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<void *>(), (pyArgs[1])))) {
        overloadId = 0; // Alarm::virtual_hook(int,void*)
    }

    // Function signature not found.
    if (overloadId == -1)
        return Shiboken::returnWrongArguments(args, "virtual_hook", SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);

    // Call function/method
    {
        int cppArg0;
        pythonToCpp[0](pyArgs[0], &cppArg0);
        void* cppArg1;
        pythonToCpp[1](pyArgs[1], &cppArg1);

        if (Shiboken::Errors::occurred() == nullptr) {
            // Alarm::virtual_hook(int,void*)
            Shiboken::Object::hasCppWrapper(reinterpret_cast<SbkObject *>(self))
                ? cppSelf->::KCalendarCore::Alarm::virtual_hook(cppArg0, cppArg1)
                : cppSelf->virtual_hook(cppArg0, cppArg1);
        }
    }

     return Sbk_ReturnFromPython_None();
}


static const char *Sbk_KCalendarCore_Alarm_PropertyStrings[] = {
    nullptr // Sentinel
};

static const char *Sbk_KCalendarCore_Alarm_EnumFlagInfo[] = {
    "Type:IntEnum",
    nullptr // Sentinel
};

static PyMethodDef Sbk_KCalendarCore_Alarm_methods[] = {
    {"addMailAddress", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_addMailAddress), METH_O, nullptr},
    {"addMailAttachment", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_addMailAttachment), METH_O, nullptr},
    {"audioFile", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_audioFile), METH_NOARGS, nullptr},
    {"customPropertyUpdated", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_customPropertyUpdated), METH_NOARGS, nullptr},
    {"duration", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_duration), METH_NOARGS, nullptr},
    {"enabled", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_enabled), METH_NOARGS, nullptr},
    {"endOffset", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_endOffset), METH_NOARGS, nullptr},
    {"endTime", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_endTime), METH_NOARGS, nullptr},
    {"hasEndOffset", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_hasEndOffset), METH_NOARGS, nullptr},
    {"hasLocationRadius", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_hasLocationRadius), METH_NOARGS, nullptr},
    {"hasStartOffset", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_hasStartOffset), METH_NOARGS, nullptr},
    {"hasTime", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_hasTime), METH_NOARGS, nullptr},
    {"locationRadius", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_locationRadius), METH_NOARGS, nullptr},
    {"mailAddresses", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_mailAddresses), METH_NOARGS, nullptr},
    {"mailAttachments", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_mailAttachments), METH_NOARGS, nullptr},
    {"mailSubject", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_mailSubject), METH_NOARGS, nullptr},
    {"mailText", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_mailText), METH_NOARGS, nullptr},
    {"nextRepetition", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_nextRepetition), METH_O, nullptr},
    {"nextTime", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_nextTime), METH_VARARGS|METH_KEYWORDS, nullptr},
    {"parentUid", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_parentUid), METH_NOARGS, nullptr},
    {"previousRepetition", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_previousRepetition), METH_O, nullptr},
    {"programArguments", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_programArguments), METH_NOARGS, nullptr},
    {"programFile", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_programFile), METH_NOARGS, nullptr},
    {"repeatCount", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_repeatCount), METH_NOARGS, nullptr},
    {"setAudioAlarm", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setAudioAlarm), METH_VARARGS|METH_KEYWORDS, nullptr},
    {"setAudioFile", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setAudioFile), METH_O, nullptr},
    {"setDisplayAlarm", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setDisplayAlarm), METH_VARARGS|METH_KEYWORDS, nullptr},
    {"setEmailAlarm", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setEmailAlarm), METH_VARARGS|METH_KEYWORDS, nullptr},
    {"setEnabled", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setEnabled), METH_O, nullptr},
    {"setEndOffset", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setEndOffset), METH_O, nullptr},
    {"setHasLocationRadius", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setHasLocationRadius), METH_O, nullptr},
    {"setLocationRadius", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setLocationRadius), METH_O, nullptr},
    {"setMailAddress", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setMailAddress), METH_O, nullptr},
    {"setMailAddresses", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setMailAddresses), METH_O, nullptr},
    {"setMailAttachment", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setMailAttachment), METH_O, nullptr},
    {"setMailAttachments", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setMailAttachments), METH_O, nullptr},
    {"setMailSubject", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setMailSubject), METH_O, nullptr},
    {"setMailText", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setMailText), METH_O, nullptr},
    {"setParent", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setParent), METH_O, nullptr},
    {"setProcedureAlarm", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setProcedureAlarm), METH_VARARGS|METH_KEYWORDS, nullptr},
    {"setProgramArguments", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setProgramArguments), METH_O, nullptr},
    {"setProgramFile", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setProgramFile), METH_O, nullptr},
    {"setRepeatCount", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setRepeatCount), METH_O, nullptr},
    {"setSnoozeTime", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setSnoozeTime), METH_O, nullptr},
    {"setStartOffset", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setStartOffset), METH_O, nullptr},
    {"setText", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setText), METH_O, nullptr},
    {"setTime", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setTime), METH_O, nullptr},
    {"setType", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_setType), METH_O, nullptr},
    {"shiftTimes", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_shiftTimes), METH_VARARGS, nullptr},
    {"snoozeTime", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_snoozeTime), METH_NOARGS, nullptr},
    {"startOffset", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_startOffset), METH_NOARGS, nullptr},
    {"text", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_text), METH_NOARGS, nullptr},
    {"time", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_time), METH_NOARGS, nullptr},
    {"toggleAlarm", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_toggleAlarm), METH_NOARGS, nullptr},
    {"type", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_type), METH_NOARGS, nullptr},
    {"virtual_hook", reinterpret_cast<PyCFunction>(Sbk_KCalendarCore_AlarmFunc_virtual_hook), METH_VARARGS, nullptr},
    {nullptr, nullptr, 0, nullptr} // Sentinel
};

static int Sbk_KCalendarCore_Alarm_setattro(PyObject *self, PyObject *name, PyObject *value)
{
    PySide::Feature::Select(self);
    if (value != nullptr && PyCallable_Check(value) != 0) {
        auto plain_inst = reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
        auto *inst = dynamic_cast<AlarmWrapper *>(plain_inst);
        if (inst != nullptr)
            inst->resetPyMethodCache();
    }
    return PyObject_GenericSetAttr(self, name, value);
}

// Rich comparison
static PyObject * Sbk_KCalendarCore_Alarm_richcompare(PyObject *self, PyObject *pyArg, int op)
{
    if (!Shiboken::Object::isValid(self))
        return {};
    [[maybe_unused]] auto &cppSelf = *reinterpret_cast< ::KCalendarCore::Alarm *>(Shiboken::Conversions::cppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), reinterpret_cast<SbkObject *>(self)));
    PyObject *pyResult{};
    [[maybe_unused]] Shiboken::Conversions::PythonToCppConversion pythonToCpp;
    switch (op) {
        case Py_NE:
            if ((pythonToCpp = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), (pyArg)))) {
                // Alarm::operator!=(const KCalendarCore::Alarm&)const->bool
                if (!Shiboken::Object::isValid(pyArg))
                    return {};
                ::KCalendarCore::Alarm *cppArg0;
                pythonToCpp(pyArg, &cppArg0);
                bool cppResult = cppSelf != (*cppArg0);
                pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), &cppResult);
            } else {
                pyResult = Py_True;
                Py_INCREF(pyResult);
            }

            break;
        case Py_EQ:
            if ((pythonToCpp = Shiboken::Conversions::pythonToCppReferenceConversion(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]), (pyArg)))) {
                // Alarm::operator==(const KCalendarCore::Alarm&)const->bool
                if (!Shiboken::Object::isValid(pyArg))
                    return {};
                ::KCalendarCore::Alarm *cppArg0;
                pythonToCpp(pyArg, &cppArg0);
                bool cppResult = cppSelf == (*cppArg0);
                pyResult = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), &cppResult);
            } else {
                pyResult = Py_False;
                Py_INCREF(pyResult);
            }

            break;
        default:
            // PYSIDE-74: By default, we redirect to object's tp_richcompare (which is `==`, `!=`).
            return FallbackRichCompare(self, pyArg, op);
    }

    return Shiboken::returnFromRichCompare(pyResult);
}

} // extern "C"

static int Sbk_KCalendarCore_Alarm_traverse(PyObject *self, visitproc visit, void *arg)
{
    auto traverseProc = reinterpret_cast<traverseproc>(PyType_GetSlot(SbkObject_TypeF(), Py_tp_traverse));
    ;
    return traverseProc(self, visit, arg);
}
static int Sbk_KCalendarCore_Alarm_clear(PyObject *self)
{
    auto clearProc = reinterpret_cast<inquiry>(PyType_GetSlot(SbkObject_TypeF(), Py_tp_clear));
    ;
    return clearProc(self);
}

// Class Definition -----------------------------------------------
extern "C" {

static PyType_Slot Sbk_KCalendarCore_Alarm_slots[] = {
    {Py_tp_base,        nullptr}, // inserted by introduceWrapperType
    {Py_tp_dealloc,     reinterpret_cast<void *>(&SbkDeallocWrapper)},
    {Py_tp_setattro,    reinterpret_cast<void *>(Sbk_KCalendarCore_Alarm_setattro)},
    {Py_tp_traverse,    reinterpret_cast<void *>(Sbk_KCalendarCore_Alarm_traverse)},
    {Py_tp_clear,       reinterpret_cast<void *>(Sbk_KCalendarCore_Alarm_clear)},
    {Py_tp_richcompare, reinterpret_cast<void *>(Sbk_KCalendarCore_Alarm_richcompare)},
    {Py_tp_methods,     reinterpret_cast<void *>(Sbk_KCalendarCore_Alarm_methods)},
    {Py_tp_init,        reinterpret_cast<void *>(Sbk_KCalendarCore_Alarm_Init)},
    {Py_tp_new,         reinterpret_cast<void *>(SbkObject_tp_new)},
    {0, nullptr}
};
static PyType_Spec Sbk_KCalendarCore_Alarm_spec = {
    "1:KCalendarCore.KCalendarCore.Alarm",
    sizeof(SbkObject),
    0,
    Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC,
    Sbk_KCalendarCore_Alarm_slots
};

} //extern "C"

static void *Sbk_KCalendarCore_Alarm_typeDiscovery([[maybe_unused]] void *cptr, [[maybe_unused]] PyTypeObject *instanceType)
{
    if (instanceType == Shiboken::SbkType< ::KCalendarCore::CustomProperties >())
        return dynamic_cast< ::KCalendarCore::Alarm *>(reinterpret_cast< ::KCalendarCore::CustomProperties *>(cptr));
    return {};
}


// Type conversion functions.

// Python to C++ enum conversion.
static void Enum_PythonToCpp_KCalendarCore_Alarm_Type(PyObject *pyIn, void *cppOut)
{
    const auto value = static_cast<::KCalendarCore::Alarm::Type>(Shiboken::Enum::getValue(pyIn));
    *reinterpret_cast<::KCalendarCore::Alarm::Type *>(cppOut) = value;

}
static PythonToCppFunc is_Enum_PythonToCpp_KCalendarCore_Alarm_Type_Convertible(PyObject *pyIn)
{
    if (PyObject_TypeCheck(pyIn, Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_Type_IDX])))
        return Enum_PythonToCpp_KCalendarCore_Alarm_Type;
    return {};
}

static PyObject *KCalendarCore_Alarm_Type_CppToPython_Enum(PyTypeObject *pyType, const void *cppIn)
{
    using IntType = std::underlying_type_t<::KCalendarCore::Alarm::Type>;
    const auto castCppIn = IntType(*reinterpret_cast<const ::KCalendarCore::Alarm::Type *>(cppIn));
    return Shiboken::Enum::newItem(pyType, castCppIn);

}

// Python to C++ pointer conversion - returns the C++ object of the Python wrapper (keeps object identity).
static void Alarm_PythonToCpp_Alarm_PTR(PyObject *pyIn, void *cppOut)
{
    Shiboken::Conversions::pythonToCppPointer(Sbk_KCalendarCore_Alarm_TypeF(), pyIn, cppOut);
}
static PythonToCppFunc is_Alarm_PythonToCpp_Alarm_PTR_Convertible(PyObject *pyIn)
{
    if (pyIn == Py_None)
        return Shiboken::Conversions::nonePythonToCppNullPtr;
    if (PyObject_TypeCheck(pyIn, Sbk_KCalendarCore_Alarm_TypeF()))
        return Alarm_PythonToCpp_Alarm_PTR;
    return {};
}

// C++ to Python pointer conversion - tries to find the Python wrapper for the C++ object (keeps object identity).
static PyObject *Alarm_PTR_CppToPython_Alarm(const void *cppIn)
{
    auto *pyOut = reinterpret_cast<PyObject *>(Shiboken::BindingManager::instance().retrieveWrapper(cppIn, Sbk_KCalendarCore_Alarm_TypeF()));
    if (pyOut) {
        Py_INCREF(pyOut);
        return pyOut;
    }
    auto *tCppIn = reinterpret_cast<const ::KCalendarCore::Alarm *>(cppIn);
    const char *typeName = typeid(*tCppIn).name();
    return Shiboken::Object::newObjectForPointer(Sbk_KCalendarCore_Alarm_TypeF(), const_cast<void *>(cppIn), false, typeName);

}

// The signatures string for the functions.
// Multiple signatures have their index "n:" in front.
#if PYSIDE6_COMOPT_COMPRESS == 0
static const char *KCalendarCore_Alarm_SignatureStrings[] = {
    "1:KCalendarCore.KCalendarCore.Alarm(self,parent:KCalendarCore.KCalendarCore.Incidence)",
    "0:KCalendarCore.KCalendarCore.Alarm(self,other:KCalendarCore.KCalendarCore.Alarm)",
    "KCalendarCore.KCalendarCore.Alarm.addMailAddress(self,mailAlarmAddress:KCalendarCore.KCalendarCore.Person)",
    "KCalendarCore.KCalendarCore.Alarm.addMailAttachment(self,mailAttachFile:QString)",
    "KCalendarCore.KCalendarCore.Alarm.audioFile(self)->QString",
    "KCalendarCore.KCalendarCore.Alarm.customPropertyUpdated(self)",
    "KCalendarCore.KCalendarCore.Alarm.duration(self)->KCalendarCore.KCalendarCore.Duration",
    "KCalendarCore.KCalendarCore.Alarm.enabled(self)->bool",
    "KCalendarCore.KCalendarCore.Alarm.endOffset(self)->KCalendarCore.KCalendarCore.Duration",
    "KCalendarCore.KCalendarCore.Alarm.endTime(self)->PySide6.QtCore.QDateTime",
    "KCalendarCore.KCalendarCore.Alarm.hasEndOffset(self)->bool",
    "KCalendarCore.KCalendarCore.Alarm.hasLocationRadius(self)->bool",
    "KCalendarCore.KCalendarCore.Alarm.hasStartOffset(self)->bool",
    "KCalendarCore.KCalendarCore.Alarm.hasTime(self)->bool",
    "KCalendarCore.KCalendarCore.Alarm.locationRadius(self)->int",
    "KCalendarCore.KCalendarCore.Alarm.mailAddresses(self)->QList[KCalendarCore.KCalendarCore.Person]",
    "KCalendarCore.KCalendarCore.Alarm.mailAttachments(self)->QStringList",
    "KCalendarCore.KCalendarCore.Alarm.mailSubject(self)->QString",
    "KCalendarCore.KCalendarCore.Alarm.mailText(self)->QString",
    "KCalendarCore.KCalendarCore.Alarm.nextRepetition(self,preTime:PySide6.QtCore.QDateTime)->PySide6.QtCore.QDateTime",
    "KCalendarCore.KCalendarCore.Alarm.nextTime(self,preTime:PySide6.QtCore.QDateTime,ignoreRepetitions:bool=false)->PySide6.QtCore.QDateTime",
    "KCalendarCore.KCalendarCore.Alarm.parentUid(self)->QString",
    "KCalendarCore.KCalendarCore.Alarm.previousRepetition(self,afterTime:PySide6.QtCore.QDateTime)->PySide6.QtCore.QDateTime",
    "KCalendarCore.KCalendarCore.Alarm.programArguments(self)->QString",
    "KCalendarCore.KCalendarCore.Alarm.programFile(self)->QString",
    "KCalendarCore.KCalendarCore.Alarm.repeatCount(self)->int",
    "KCalendarCore.KCalendarCore.Alarm.setAudioAlarm(self,audioFile:QString=QString())",
    "KCalendarCore.KCalendarCore.Alarm.setAudioFile(self,audioFile:QString)",
    "KCalendarCore.KCalendarCore.Alarm.setDisplayAlarm(self,text:QString=QString())",
    "KCalendarCore.KCalendarCore.Alarm.setEmailAlarm(self,subject:QString,text:QString,addressees:QList[KCalendarCore.KCalendarCore.Person],attachments:QStringList=QStringList())",
    "KCalendarCore.KCalendarCore.Alarm.setEnabled(self,enable:bool)",
    "KCalendarCore.KCalendarCore.Alarm.setEndOffset(self,offset:typing.Union[KCalendarCore.KCalendarCore.Duration, int])",
    "KCalendarCore.KCalendarCore.Alarm.setHasLocationRadius(self,hasLocationRadius:bool)",
    "KCalendarCore.KCalendarCore.Alarm.setLocationRadius(self,locationRadius:int)",
    "KCalendarCore.KCalendarCore.Alarm.setMailAddress(self,mailAlarmAddress:KCalendarCore.KCalendarCore.Person)",
    "KCalendarCore.KCalendarCore.Alarm.setMailAddresses(self,mailAlarmAddresses:QList[KCalendarCore.KCalendarCore.Person])",
    "KCalendarCore.KCalendarCore.Alarm.setMailAttachment(self,mailAttachFile:QString)",
    "KCalendarCore.KCalendarCore.Alarm.setMailAttachments(self,mailAttachFiles:QStringList)",
    "KCalendarCore.KCalendarCore.Alarm.setMailSubject(self,mailAlarmSubject:QString)",
    "KCalendarCore.KCalendarCore.Alarm.setMailText(self,text:QString)",
    "KCalendarCore.KCalendarCore.Alarm.setParent(self,parent:KCalendarCore.KCalendarCore.Incidence)",
    "KCalendarCore.KCalendarCore.Alarm.setProcedureAlarm(self,programFile:QString,arguments:QString=QString())",
    "KCalendarCore.KCalendarCore.Alarm.setProgramArguments(self,arguments:QString)",
    "KCalendarCore.KCalendarCore.Alarm.setProgramFile(self,programFile:QString)",
    "KCalendarCore.KCalendarCore.Alarm.setRepeatCount(self,alarmRepeatCount:int)",
    "KCalendarCore.KCalendarCore.Alarm.setSnoozeTime(self,alarmSnoozeTime:typing.Union[KCalendarCore.KCalendarCore.Duration, int])",
    "KCalendarCore.KCalendarCore.Alarm.setStartOffset(self,offset:typing.Union[KCalendarCore.KCalendarCore.Duration, int])",
    "KCalendarCore.KCalendarCore.Alarm.setText(self,text:QString)",
    "KCalendarCore.KCalendarCore.Alarm.setTime(self,alarmTime:PySide6.QtCore.QDateTime)",
    "KCalendarCore.KCalendarCore.Alarm.setType(self,type:KCalendarCore.KCalendarCore.Alarm.Type)",
    "KCalendarCore.KCalendarCore.Alarm.shiftTimes(self,oldZone:typing.Union[PySide6.QtCore.QTimeZone, PySide6.QtCore.QTimeZone.Initialization],newZone:typing.Union[PySide6.QtCore.QTimeZone, PySide6.QtCore.QTimeZone.Initialization])",
    "KCalendarCore.KCalendarCore.Alarm.snoozeTime(self)->KCalendarCore.KCalendarCore.Duration",
    "KCalendarCore.KCalendarCore.Alarm.startOffset(self)->KCalendarCore.KCalendarCore.Duration",
    "KCalendarCore.KCalendarCore.Alarm.text(self)->QString",
    "KCalendarCore.KCalendarCore.Alarm.time(self)->PySide6.QtCore.QDateTime",
    "KCalendarCore.KCalendarCore.Alarm.toggleAlarm(self)",
    "KCalendarCore.KCalendarCore.Alarm.type(self)->KCalendarCore.KCalendarCore.Alarm.Type",
    "KCalendarCore.KCalendarCore.Alarm.virtual_hook(self,id:int,data:void)",
    "KCalendarCore.KCalendarCore.Alarm.__ne__(self,a:KCalendarCore.KCalendarCore.Alarm)->bool",
    "KCalendarCore.KCalendarCore.Alarm.__eq__(self,a:KCalendarCore.KCalendarCore.Alarm)->bool",
    nullptr}; // Sentinel
#else
static constexpr size_t KCalendarCore_Alarm_SignatureByteSize = 787;
static constexpr uint8_t KCalendarCore_Alarm_SignatureBytes[787] = {
    0x78, 0xda, 0xbd, 0x58, 0xdf, 0x4f, 0xdb, 0x30, 0x10, 0x7e, 0xe7, 0xaf, 0xe0, 0x91, 0x4a, 0xa1,
    0xda, 0x5e, 0xf6, 0x10, 0x09, 0xa4, 0x0a, 0x98, 0x36, 0x8d, 0x69, 0x2d, 0x85, 0x97, 0x21, 0x14,
    0x99, 0xf8, 0xda, 0x7a, 0x73, 0xec, 0xcc, 0x76, 0xd8, 0xca, 0x5f, 0x3f, 0x3b, 0x49, 0xf3, 0xab,
    0xa1, 0x3d, 0x87, 0xc2, 0x53, 0x53, 0xc7, 0xf7, 0xdd, 0xe7, 0xeb, 0xdd, 0x7d, 0xbe, 0x7e, 0x0c,
    0xbf, 0x5d, 0x10, 0x0e, 0x82, 0x12, 0x75, 0x21, 0x15, 0x8c, 0xdb, 0xdf, 0x26, 0x9c, 0xa8, 0xe4,
    0x44, 0x03, 0x5f, 0x04, 0x29, 0x51, 0x20, 0xcc, 0xce, 0xdd, 0x5f, 0x45, 0xcc, 0x28, 0x88, 0x18,
    0x46, 0x47, 0x1f, 0xb0, 0xb0, 0xd2, 0xac, 0x40, 0xed, 0xdf, 0x3c, 0x3a, 0xda, 0xbb, 0x65, 0x4c,
    0x28, 0xfd, 0x4e, 0x18, 0x9f, 0x50, 0xaa, 0x40, 0xeb, 0x02, 0x3e, 0x71, 0x0b, 0xee, 0x6d, 0xb9,
    0xba, 0xd3, 0xd3, 0x14, 0x94, 0x96, 0xc2, 0xc7, 0x95, 0x31, 0x24, 0x5e, 0x25, 0x36, 0x2e, 0x0d,
    0x6f, 0xf9, 0xda, 0x67, 0xc6, 0x21, 0x9c, 0xcd, 0x8d, 0x62, 0x62, 0x89, 0x02, 0xcc, 0x28, 0x93,
    0xce, 0x28, 0x07, 0x1a, 0x9d, 0x9e, 0x97, 0xb6, 0x08, 0xd3, 0x38, 0xd3, 0x46, 0x26, 0x53, 0x25,
    0x53, 0x50, 0x66, 0x7d, 0x97, 0x52, 0x62, 0x80, 0x16, 0x30, 0x08, 0x6b, 0x9a, 0x29, 0x62, 0x98,
    0x14, 0x1b, 0xbf, 0xbb, 0x2c, 0x2e, 0xcb, 0xbd, 0x08, 0x58, 0x10, 0xe4, 0x91, 0x6f, 0x68, 0x9c,
    0x9e, 0x3f, 0x4a, 0xc9, 0x51, 0x56, 0xf4, 0xc7, 0x62, 0xa1, 0xc1, 0x1c, 0x9c, 0x0d, 0xbd, 0x65,
    0x49, 0x15, 0xdb, 0xe9, 0x7a, 0x6e, 0xf3, 0xf4, 0xd3, 0x78, 0x66, 0xf2, 0x3d, 0xb3, 0x4b, 0x1b,
    0x31, 0xf7, 0x1e, 0x81, 0xb4, 0x22, 0xfa, 0xaa, 0x4b, 0x12, 0x79, 0x38, 0x6b, 0x7a, 0x2d, 0xe3,
    0x9c, 0xf2, 0x0d, 0xa1, 0x2c, 0xd3, 0xfe, 0xf6, 0x73, 0x43, 0x94, 0x19, 0xea, 0xbc, 0x19, 0x01,
    0xa4, 0x15, 0xef, 0xe5, 0xcb, 0x84, 0x41, 0xd8, 0x26, 0x75, 0x29, 0x42, 0x65, 0x3a, 0xbb, 0x66,
    0xda, 0xdc, 0xef, 0xaf, 0xc1, 0x07, 0xac, 0x83, 0xaa, 0x00, 0x75, 0xa7, 0x70, 0x9c, 0x23, 0x24,
    0xc8, 0x3c, 0x7b, 0xfc, 0x05, 0xb1, 0xf1, 0xaf, 0x3c, 0x67, 0x7c, 0x0b, 0xff, 0x06, 0x58, 0x0a,
    0x6b, 0x75, 0x03, 0x29, 0x18, 0x56, 0xd5, 0x5e, 0x90, 0xaa, 0x3c, 0x09, 0xc3, 0x97, 0xb2, 0xf3,
    0x75, 0x89, 0xeb, 0x3c, 0x56, 0x19, 0xb0, 0xd7, 0x57, 0xc0, 0x96, 0xc2, 0x2e, 0xd4, 0x14, 0x75,
    0xe8, 0x52, 0xe6, 0x6c, 0x41, 0xb8, 0x7e, 0x25, 0x91, 0x42, 0x47, 0xee, 0x18, 0xf5, 0x8f, 0x9a,
    0x65, 0xfd, 0xc4, 0x64, 0xa6, 0xbb, 0x91, 0x23, 0x0b, 0x03, 0xea, 0x0d, 0x63, 0x97, 0x2a, 0xb9,
    0x54, 0x24, 0x99, 0xa8, 0x65, 0xd6, 0x97, 0x6a, 0x78, 0x84, 0x61, 0x0d, 0x5e, 0xd9, 0xe3, 0x12,
    0xcb, 0x3a, 0x13, 0xc6, 0xaf, 0x04, 0x6d, 0x9b, 0x98, 0x38, 0x5d, 0x69, 0xc8, 0x6d, 0xa5, 0x33,
    0x1b, 0x71, 0x3a, 0x2b, 0x3f, 0x4f, 0x46, 0x23, 0x0f, 0xc4, 0xea, 0x20, 0xdb, 0x80, 0x48, 0x98,
    0x4b, 0xa6, 0x53, 0x4e, 0xd6, 0x0d, 0x6a, 0xc6, 0x66, 0xe8, 0x60, 0x56, 0x57, 0x95, 0xd0, 0x17,
    0x60, 0xba, 0xa8, 0xe9, 0x0d, 0x5e, 0x0b, 0x3c, 0x20, 0x65, 0x5b, 0x02, 0x1d, 0xa2, 0x1b, 0x52,
    0x40, 0xea, 0x56, 0x13, 0x36, 0x7a, 0xcc, 0x59, 0xe3, 0x19, 0xcf, 0xb6, 0xa1, 0x8e, 0x41, 0x21,
    0x95, 0x79, 0x7d, 0xa1, 0xcd, 0x9b, 0x0a, 0x14, 0xc8, 0xfc, 0x39, 0x34, 0xeb, 0xd4, 0xf2, 0x18,
    0xdf, 0x09, 0x5b, 0x17, 0xf7, 0x18, 0xe1, 0x0c, 0x8e, 0x6d, 0x1a, 0x3d, 0x20, 0x7d, 0x7e, 0xe9,
    0x55, 0xaf, 0x60, 0x4b, 0xd4, 0x7c, 0xce, 0xd1, 0x07, 0xd8, 0x96, 0x9c, 0xd0, 0x32, 0x44, 0x82,
    0xbd, 0xd7, 0xd5, 0xaf, 0xed, 0x0a, 0x5e, 0x70, 0xe6, 0x93, 0x5a, 0x3e, 0x5e, 0x0f, 0x76, 0xe1,
    0xdc, 0x02, 0xd4, 0x7d, 0x88, 0xad, 0x54, 0xf7, 0x80, 0x6d, 0x4a, 0x6a, 0x1d, 0x9b, 0x79, 0xbb,
    0x28, 0x3d, 0xf0, 0x2a, 0x95, 0x6d, 0x15, 0x32, 0x12, 0x60, 0x9a, 0x2b, 0xce, 0x90, 0x29, 0x06,
    0x07, 0xaf, 0x64, 0x0c, 0xf6, 0x1a, 0x0d, 0xcd, 0x61, 0xa9, 0xee, 0xf7, 0x75, 0xd7, 0xd9, 0xc8,
    0xc7, 0xe0, 0x26, 0x37, 0xed, 0xd3, 0xa1, 0x6d, 0x5c, 0x3f, 0xb4, 0xba, 0x95, 0xf7, 0x90, 0x46,
    0x42, 0xdd, 0x74, 0x14, 0x2a, 0x20, 0xee, 0x4d, 0x63, 0xd5, 0xa3, 0x8e, 0xe7, 0x42, 0xca, 0x67,
    0xa8, 0xaf, 0x2a, 0x39, 0x54, 0xbd, 0xf8, 0xc6, 0x6d, 0xae, 0x7b, 0xc3, 0x7e, 0x9f, 0xe6, 0xfa,
    0xaa, 0xf4, 0xee, 0x84, 0x6a, 0xf7, 0x3d, 0x08, 0x09, 0xb9, 0x4e, 0x4b, 0x48, 0x7b, 0x6e, 0xd8,
    0x3f, 0x9d, 0x8f, 0x9d, 0x01, 0x0a, 0x7b, 0xc5, 0x16, 0x39, 0xe1, 0x32, 0x77, 0x25, 0xa7, 0x3f,
    0xa5, 0xe8, 0xfc, 0xa8, 0x5d, 0xf2, 0x6e, 0xbf, 0xdb, 0x15, 0x1c, 0xbf, 0xf4, 0xc6, 0xd6, 0xac,
    0xbd, 0x0e, 0x12, 0xce, 0x9e, 0xf3, 0xd8, 0x3f, 0x04, 0x02, 0xfe, 0xbe, 0x05, 0x2e, 0xea, 0x88,
    0xed, 0xfc, 0x3d, 0xdc, 0x10, 0xab, 0xb7, 0x87, 0xbf, 0x03, 0x21, 0x9b, 0x41, 0x33, 0x8c, 0x39,
    0xcc, 0x44, 0x6d, 0xe4, 0x72, 0xc9, 0x1b, 0xbd, 0x13, 0x13, 0x63, 0xb3, 0xc9, 0xcf, 0x3d, 0x31,
    0xa8, 0x93, 0x13, 0x01, 0xfa, 0xc4, 0x94, 0xc9, 0x08, 0x8f, 0x56, 0x52, 0xfe, 0x2e, 0xb2, 0x93,
    0x51, 0xd7, 0xb7, 0x02, 0x4a, 0x0c, 0x09, 0x9f, 0x24, 0xa3, 0x18, 0x6a, 0x51, 0x24, 0x20, 0x8a,
    0xca, 0x7a, 0x44, 0xfc, 0xaf, 0x85, 0x9e, 0xc5, 0xa3, 0x08, 0xfe, 0x0c, 0x00, 0xfe, 0x0f, 0xc0,
    0x16, 0x3f, 0x04
};
#endif

PyTypeObject *init_KCalendarCore_Alarm(PyObject *enclosingClass)
{
    auto &typeStruct = SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX];
    if (typeStruct.type != nullptr)
        return typeStruct.type;

    auto *base1 = reinterpret_cast<PyObject *>(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_CustomProperties_IDX]));
    Shiboken::AutoDecRef Sbk_KCalendarCore_Alarm_Type_bases(PyTuple_Pack(1, base1));

    PyTypeObject *pyType = Shiboken::ObjectType::introduceWrapperType(
        enclosingClass,
        "Alarm",
        "KCalendarCore::Alarm*",
        &Sbk_KCalendarCore_Alarm_spec,
        &Shiboken::callCppDestructor< KCalendarCore::Alarm >,
        Sbk_KCalendarCore_Alarm_Type_bases.object(),
        Shiboken::ObjectType::WrapperFlags::InnerClass);
#if PYSIDE6_COMOPT_COMPRESS == 0
    InitSignatureStrings(pyType, KCalendarCore_Alarm_SignatureStrings);
#else
    InitSignatureBytes(pyType, KCalendarCore_Alarm_SignatureBytes, KCalendarCore_Alarm_SignatureByteSize);
#endif
    SbkObjectType_SetPropertyStrings(pyType, Sbk_KCalendarCore_Alarm_PropertyStrings);
    typeStruct.type = pyType;

    // Register Converter
    SbkConverter *converter = Shiboken::Conversions::createConverter(pyType,
        Alarm_PythonToCpp_Alarm_PTR,
        is_Alarm_PythonToCpp_Alarm_PTR_Convertible,
        Alarm_PTR_CppToPython_Alarm);

    Shiboken::Conversions::registerConverterName(converter, "KCalendarCore::Alarm");
    Shiboken::Conversions::registerConverterName(converter, "KCalendarCore::Alarm*");
    Shiboken::Conversions::registerConverterName(converter, "KCalendarCore::Alarm&");
    Shiboken::Conversions::registerConverterAlias(converter, "Alarm");
    Shiboken::Conversions::registerConverterAlias(converter, "Alarm*");
    Shiboken::Conversions::registerConverterAlias(converter, "Alarm&");
    Shiboken::Conversions::registerConverterName(converter, typeid(::KCalendarCore::Alarm).name());
    Shiboken::Conversions::registerConverterName(converter, typeid(AlarmWrapper).name());

    Shiboken::ObjectType::setTypeDiscoveryFunctionV2(pyType, &Sbk_KCalendarCore_Alarm_typeDiscovery);

    // Pass the ..._EnumFlagInfo to the class.
    SbkObjectType_SetEnumFlagInfo(pyType, Sbk_KCalendarCore_Alarm_EnumFlagInfo);

    // Initialization of enums.
    Shiboken::AutoDecRef tpDict{};
    [[maybe_unused]] PyTypeObject *EType{};

    // Initialization of enum 'Type'.
    const char *Type_Initializer[] = {
        "Invalid",
        "Display",
        "Procedure",
        "Email",
        "Audio",
        nullptr};
    // "uint8_t" used instead of "unsigned int"
    constexpr uint8_t Type_InitializerValues[] = {
        uint8_t(KCalendarCore::Alarm::Type::Invalid),   //  0x00  0
        uint8_t(KCalendarCore::Alarm::Type::Display),   //  0x01  1
        uint8_t(KCalendarCore::Alarm::Type::Procedure), //  0x02  2
        uint8_t(KCalendarCore::Alarm::Type::Email),     //  0x03  3
        uint8_t(KCalendarCore::Alarm::Type::Audio)      //  0x04  4
        };
    EType = Shiboken::Enum::createPythonEnum(pyType,
        "1:KCalendarCore.KCalendarCore.Alarm.Type",
        Type_Initializer, Type_InitializerValues);
    SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_Type_IDX].type = EType;
    // Register converter for enum 'KCalendarCore::Alarm::Type'.
    {
        SbkConverter *converter = Shiboken::Conversions::createConverter(EType,
            KCalendarCore_Alarm_Type_CppToPython_Enum);
        Shiboken::Conversions::addPythonToCppValueConversion(converter,
            Enum_PythonToCpp_KCalendarCore_Alarm_Type,
            is_Enum_PythonToCpp_KCalendarCore_Alarm_Type_Convertible);
        Shiboken::Conversions::registerConverterName(converter, "KCalendarCore::Alarm::Type");
        Shiboken::Conversions::registerConverterAlias(converter, "Alarm::Type");
        Shiboken::Conversions::registerConverterAlias(converter, "Type");
        Shiboken::Enum::setTypeConverter(EType, converter, nullptr);
    }
    // End of 'Type' enum.

    qRegisterMetaType< ::KCalendarCore::Alarm *>();
    qRegisterMetaType< ::KCalendarCore::Alarm::Type >("Alarm::Type");
    qRegisterMetaType< ::KCalendarCore::Alarm::Type >("KCalendarCore::Alarm::Type");

    return pyType;
}
