
#include <sbkpep.h>
#include <shiboken.h>
#include <sbkbindingutils.h>
#include <algorithm>
#include <signature.h>
#include <sbkcontainer.h>
#include <sbkstaticstrings.h>

#define PYSIDE6_COMOPT_COMPRESS 1

#ifndef QT_NO_VERSION_TAGGING
#  define QT_NO_VERSION_TAGGING
#endif
#include <QtCore/QDebug>
#include <pysidecleanup.h>
#include <pysideqenum.h>
#include <feature_select.h>
#include <pysidestaticstrings.h>
#include "kcalendarcore_python.h"

#include <QHash>
#include <QList>
#include <QMap>
#include <QSet>
#include <QString>
#include <attachment.h>
#include <attendee.h>
#include <conference.h>
#include <freebusyperiod.h>
#include <incidencebase.h>
#include <period.h>
#include <person.h>
#include <qabstractitemmodel.h>
#include <qbytearray.h>
#include <qdatetime.h>
#include <qvariant.h>
#include <recurrencerule.h>


// Current module's type array.
Shiboken::Module::TypeInitStruct *SbkKCalendarCoreTypeStructs = nullptr;
// Current module's converter array.
SbkConverter **SbkKCalendarCoreTypeConverters = nullptr;

void cleanTypesAttributes() {
    static PyObject *attrName = Shiboken::PyName::qtStaticMetaObject();
    const int imax = SBK_KCalendarCore_IDX_COUNT;
    for (int i = 0; i < imax && SbkKCalendarCoreTypeStructs[i].fullName != nullptr; ++i) {
        auto *pyType = reinterpret_cast<PyObject *>(SbkKCalendarCoreTypeStructs[i].type);
        if (pyType != nullptr && PyObject_HasAttr(pyType, attrName))
            PyObject_SetAttr(pyType, attrName, Py_None);
    }
}

// Global functions ------------------------------------------------------------

static PyMethodDef KCalendarCoreMethods[] = {
    {nullptr, nullptr, 0, nullptr} // Sentinel
};

// Classes initialization functions ------------------------------------------------------------
PyTypeObject *init_KCalendarCoreKCalendarCore(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Visitor(PyObject *enclosing);
PyTypeObject *init_KCalendarCoreKCalendarCore_Todos(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_ScheduleMessage(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_RecurrenceRule(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_RecurrenceRule_RuleObserver(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Recurrence(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Recurrence_RecurrenceObserver(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Person(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Period(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_OccurrenceIterator(PyObject *enclosing);
PyTypeObject *init_KCalendarCoreKCalendarCore_Journals(PyObject *enclosing);
PyTypeObject *init_KCalendarCoreKCalendarCore_Incidences(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_FreeBusyPeriod(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_FreeBusyCache(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Exception(PyObject *enclosing);
PyTypeObject *init_KCalendarCoreKCalendarCore_Events(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Duration(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_CustomProperties(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_IncidenceBase(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_IncidenceBase_IncidenceObserver(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Incidence(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Todo(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Journal(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Event(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_FreeBusy(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Conference(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_CalendarPluginLoader(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_CalendarPlugin(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_CalendarListModel(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Calendar(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_MemoryCalendar(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_CalStorage(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_FileStorage(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_CalFormat(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_VCalFormat(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_ICalFormat(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_CalFilter(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Attendee(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Attachment(PyObject *enclosing);
PyTypeObject *init_KCalendarCore_Alarm(PyObject *enclosing);

// Required modules' type and converter arrays.
Shiboken::Module::TypeInitStruct *SbkPySide6_QtCoreTypeStructs;
SbkConverter **SbkPySide6_QtCoreTypeConverters;
Shiboken::Module::TypeInitStruct *SbkPySide6_QtGuiTypeStructs;
SbkConverter **SbkPySide6_QtGuiTypeConverters;

// Module initialization ------------------------------------------------------------
// Container Type converters.

// C++ to Python conversion for container type 'QList<int>'.
static PyObject *_QList_int__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<int> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<int>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_int_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<int> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        int cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter<int>(), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_int__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Conversions::PrimitiveTypeConverter<int>(), pyIn))
        return PySequence_PythonToCpp__QList_int_;
    return {};
}


// Binding for QList<int>

template <>
struct ShibokenContainerValueConverter<int>
{
    static bool checkValue(PyObject *pyArg)
    {
        return PyLong_Check(pyArg);
    }

    static PyObject *convertValueToPython(int cppArg)
    {
        return Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &cppArg);
    }

    static std::optional<int> convertValueToCpp(PyObject *pyArg)
    {
        Shiboken::Conversions::PythonToCppConversion pythonToCpp;
        if (!(PyLong_Check(pyArg) && (pythonToCpp = Shiboken::Conversions::pythonToCppConversion(Shiboken::Conversions::PrimitiveTypeConverter<int>(), (pyArg))))) {
            Shiboken::Errors::setWrongContainerType();
            return {};
        }
        int cppArg;
        pythonToCpp(pyArg, &cppArg);
        return cppArg;
    }
};

static PyMethodDef QIntList_methods[] = {
    {"push_back", reinterpret_cast<PyCFunction>(ShibokenSequenceContainerPrivate<QList<int>>::push_back), METH_O, "push_back"},
    {"append", reinterpret_cast<PyCFunction>(ShibokenSequenceContainerPrivate<QList<int>>::push_back), METH_O, "append"},
    {"clear", reinterpret_cast<PyCFunction>(ShibokenSequenceContainerPrivate<QList<int>>::clear), METH_NOARGS, "clear"},
    {"pop_back", reinterpret_cast<PyCFunction>(ShibokenSequenceContainerPrivate<QList<int>>::pop_back), METH_NOARGS, "pop_back"},
    {"removeLast", reinterpret_cast<PyCFunction>(ShibokenSequenceContainerPrivate<QList<int>>::pop_back), METH_NOARGS, "removeLast"},
    {"push_front", reinterpret_cast<PyCFunction>(ShibokenSequenceContainerPrivate<QList<int>>::push_front), METH_O, "push_front"},
    {"prepend", reinterpret_cast<PyCFunction>(ShibokenSequenceContainerPrivate<QList<int>>::push_front), METH_O, "prepend"},
    {"pop_front", reinterpret_cast<PyCFunction>(ShibokenSequenceContainerPrivate<QList<int>>::pop_front), METH_NOARGS, "pop_front"},
    {"removeFirst", reinterpret_cast<PyCFunction>(ShibokenSequenceContainerPrivate<QList<int>>::pop_front), METH_O, "removeFirst"},
    {"reserve", reinterpret_cast<PyCFunction>(ShibokenSequenceContainerPrivate<QList<int>>::reserve), METH_O, "reserve"},
    {"capacity", reinterpret_cast<PyCFunction>(ShibokenSequenceContainerPrivate<QList<int>>::capacity), METH_NOARGS, "capacity"},
    {"data", reinterpret_cast<PyCFunction>(ShibokenSequenceContainerPrivate<QList<int>>::data), METH_NOARGS, "data"},
    {"constData", reinterpret_cast<PyCFunction>(ShibokenSequenceContainerPrivate<QList<int>>::constData), METH_NOARGS, "constData"},
    {nullptr, nullptr, 0, nullptr} // Sentinel
};

static PyType_Slot QIntList_slots[] = {
    {Py_tp_init, reinterpret_cast<void *>(ShibokenSequenceContainerPrivate<QList<int>>::tpInit)},
    {Py_tp_new, reinterpret_cast<void *>(ShibokenSequenceContainerPrivate<QList<int>>::tpNew)},
    {Py_tp_free, reinterpret_cast<void *>(ShibokenSequenceContainerPrivate<QList<int>>::tpFree)},
    {Py_tp_dealloc, reinterpret_cast<void *>(Sbk_object_dealloc)},
    {Py_tp_methods, reinterpret_cast<void *>(QIntList_methods)},
    {Py_sq_ass_item, reinterpret_cast<void *>(ShibokenSequenceContainerPrivate<QList<int>>::sqSetItem)},
    {Py_sq_length, reinterpret_cast<void *>(ShibokenSequenceContainerPrivate<QList<int>>::sqLen)},
    {Py_sq_item, reinterpret_cast<void *>(ShibokenSequenceContainerPrivate<QList<int>>::sqGetItem)},
    {0, nullptr}
};

static PyType_Spec QIntList_spec = {
    "1:KCalendarCore.QIntList",
    sizeof(ShibokenContainer),
    0,
    Py_TPFLAGS_DEFAULT,
    QIntList_slots
};

static inline PyTypeObject *createQIntListType()
{
    auto *result = SbkType_FromSpec(&QIntList_spec);
    Py_INCREF(Py_True);
    Shiboken::AutoDecRef tpDict(PepType_GetDict(result));
    PyDict_SetItem(tpDict.object(), Shiboken::PyMagicName::opaque_container(), Py_True);
    return result;
}

static PyTypeObject *QIntList_TypeF()
{
    static PyTypeObject *type = createQIntListType();
    return type;
}

extern "C" PyObject *createQIntList(QList<int>* ct)
{
    auto *container = PyObject_New(ShibokenContainer, QIntList_TypeF());
    auto *d = new ShibokenSequenceContainerPrivate<QList<int>>();
    d->m_list = ct;
    container->d = d;
    return reinterpret_cast<PyObject *>(container);
}

extern "C" PyObject *createConstQIntList(const QList<int>* ct)
{
    auto *container = PyObject_New(ShibokenContainer, QIntList_TypeF());
    auto *d = new ShibokenSequenceContainerPrivate<QList<int>>();
    d->m_list = const_cast<QList<int> *>(ct);
    d->m_const = true;
    container->d = d;
    return reinterpret_cast<PyObject *>(container);
}

extern "C" int QIntList_Check(PyObject *pyArg)
{
    return pyArg != nullptr && pyArg != Py_None && pyArg->ob_type == QIntList_TypeF();
}

extern "C" void PythonToCppQIntList(PyObject *pyArg, void *cppOut)
{
    auto *d = ShibokenSequenceContainerPrivate<QList<int>>::get(pyArg);
    *reinterpret_cast<QList<int>**>(cppOut) = d->m_list;
}

extern "C" PythonToCppFunc isQIntListPythonToCppConvertible(PyObject *pyArg)
{
    if (QIntList_Check(pyArg))
        return PythonToCppQIntList;
    return {};
}

extern "C" void PythonToQVariantQIntList(PyObject *pyArg, void *cppOut)
{
    auto *d = ShibokenSequenceContainerPrivate<QList<int>>::get(pyArg);
    *reinterpret_cast<QVariant *>(cppOut) = QVariant::fromValue(*d->m_list);
}

extern "C" PythonToCppFunc isQIntListPythonToQVariantConvertible(PyObject *pyArg)
{
    if (QIntList_Check(pyArg))
        return PythonToQVariantQIntList;
    return {};
}

// C++ to Python conversion for container type 'QList<KCalendarCore::Person>'.
static PyObject *_QList_KCalendarCore_Person__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<KCalendarCore::Person> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<::KCalendarCore::Person>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Person_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_KCalendarCore_Person_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<KCalendarCore::Person> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::KCalendarCore::Person* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Person_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(*cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_KCalendarCore_Person__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Person_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_KCalendarCore_Person_;
    return {};
}

// C++ to Python conversion for container type 'QList<QDateTime>'.
static PyObject *_QList_QDateTime__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QDateTime> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<::QDateTime>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDateTime_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_QDateTime_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QDateTime> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::QDateTime cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDateTime_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_QDateTime__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDateTime_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_QDateTime_;
    return {};
}

// C++ to Python conversion for container type 'QList<KCalendarCore::Attachment>'.
static PyObject *_QList_KCalendarCore_Attachment__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<KCalendarCore::Attachment> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<::KCalendarCore::Attachment>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Attachment_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_KCalendarCore_Attachment_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<KCalendarCore::Attachment> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::KCalendarCore::Attachment cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Attachment_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_KCalendarCore_Attachment__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Attachment_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_KCalendarCore_Attachment_;
    return {};
}

// C++ to Python conversion for container type 'QList<KCalendarCore::Conference>'.
static PyObject *_QList_KCalendarCore_Conference__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<KCalendarCore::Conference> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<::KCalendarCore::Conference>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Conference_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_KCalendarCore_Conference_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<KCalendarCore::Conference> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::KCalendarCore::Conference cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Conference_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_KCalendarCore_Conference__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Conference_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_KCalendarCore_Conference_;
    return {};
}

// C++ to Python conversion for container type 'QList<KCalendarCore::FreeBusyPeriod>'.
static PyObject *_QList_KCalendarCore_FreeBusyPeriod__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<KCalendarCore::FreeBusyPeriod> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<::KCalendarCore::FreeBusyPeriod>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_FreeBusyPeriod_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_KCalendarCore_FreeBusyPeriod_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<KCalendarCore::FreeBusyPeriod> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::KCalendarCore::FreeBusyPeriod* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_FreeBusyPeriod_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(*cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_KCalendarCore_FreeBusyPeriod__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_FreeBusyPeriod_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_KCalendarCore_FreeBusyPeriod_;
    return {};
}

// C++ to Python conversion for container type 'QList<KCalendarCore::Period>'.
static PyObject *_QList_KCalendarCore_Period__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<KCalendarCore::Period> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<::KCalendarCore::Period>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Period_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_KCalendarCore_Period_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<KCalendarCore::Period> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::KCalendarCore::Period cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Period_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_KCalendarCore_Period__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Period_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_KCalendarCore_Period_;
    return {};
}

// C++ to Python conversion for container type 'QList<KCalendarCore::Attendee>'.
static PyObject *_QList_KCalendarCore_Attendee__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<KCalendarCore::Attendee> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<::KCalendarCore::Attendee>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Attendee_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_KCalendarCore_Attendee_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<KCalendarCore::Attendee> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::KCalendarCore::Attendee cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Attendee_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_KCalendarCore_Attendee__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Attendee_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_KCalendarCore_Attendee_;
    return {};
}

// C++ to Python conversion for container type 'QSet<KCalendarCore::IncidenceBase::Field>'.
static PyObject *_QSet_KCalendarCore_IncidenceBase_Field__CppToPython_PySet(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QSet<KCalendarCore::IncidenceBase::Field> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pyset - START
    PyObject *pyOut = PySet_New(nullptr);
    for (const auto &cppItem : cppInRef) {
        PySet_Add(pyOut, Shiboken::Conversions::copyToPython(Shiboken::Enum::getConverter(reinterpret_cast<SbkEnumType *>(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_IncidenceBase_Field_IDX]))), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pyset - END

}
static void PySequence_PythonToCpp__QSet_KCalendarCore_IncidenceBase_Field_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QSet<KCalendarCore::IncidenceBase::Field> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsetcontainer - START
    (cppOutRef).clear();
    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::KCalendarCore::IncidenceBase::Field cppItem{KCalendarCore::IncidenceBase::FieldDtStart};
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Enum::getConverter(reinterpret_cast<SbkEnumType *>(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_IncidenceBase_Field_IDX]))), pyItem, &(cppItem));
        (cppOutRef).insert(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsetcontainer - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QSet_KCalendarCore_IncidenceBase_Field__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleIterableTypes(Shiboken::Enum::getConverter(reinterpret_cast<SbkEnumType *>(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_IncidenceBase_Field_IDX]))), pyIn))
        return PySequence_PythonToCpp__QSet_KCalendarCore_IncidenceBase_Field_;
    return {};
}

// C++ to Python conversion for container type 'QMap<QByteArray,QString>'.
static PyObject *_QMap_QByteArray_QString__CppToPython_PyDict(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QMap<QByteArray,QString> *>(cppIn);
    // TEMPLATE - shiboken_conversion_qmap_to_pydict - START
    PyObject *pyOut = PyDict_New();
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it) {
        const auto &key = it.key();
        const auto &value = it.value();
        PyObject *pyKey = Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX]), &key);
        PyObject *pyValue = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], &value);
        PyDict_SetItem(pyOut, pyKey, pyValue);
        Py_DECREF(pyKey);
        Py_DECREF(pyValue);
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_qmap_to_pydict - END

}
static void PyDict_PythonToCpp__QMap_QByteArray_QString_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QMap<QByteArray,QString> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pydict_to_qmap - START
    PyObject *key{};
    PyObject *value{};
    cppOutRef.clear();
    Py_ssize_t pos = 0;
    while (PyDict_Next(pyIn, &pos, &key, &value)) {
        ::QByteArray cppKey;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX]), key, &(cppKey));
        ::QString cppValue;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], value, &(cppValue));
        cppOutRef.insert(cppKey, cppValue);
    }
    // TEMPLATE - shiboken_conversion_pydict_to_qmap - END

}
static PythonToCppFunc is_PyDict_PythonToCpp__QMap_QByteArray_QString__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleDictTypes(Shiboken::Object::getConverter(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX])), false, SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], false, pyIn))
        return PyDict_PythonToCpp__QMap_QByteArray_QString_;
    return {};
}

// C++ to Python conversion for container type 'QList<QTime>'.
static PyObject *_QList_QTime__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QTime> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<::QTime>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QTime_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_QTime_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QTime> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::QTime cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QTime_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_QTime__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QTime_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_QTime_;
    return {};
}

// C++ to Python conversion for container type 'QList<QDate>'.
static PyObject *_QList_QDate__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QDate> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<::QDate>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDate_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_QDate_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QDate> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::QDate cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDate_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_QDate__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QDate_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_QDate_;
    return {};
}

// C++ to Python conversion for container type 'QList<KCalendarCore::RecurrenceRule*>'.
static PyObject *_QList_KCalendarCore_RecurrenceRulePTR__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<KCalendarCore::RecurrenceRule*> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<::KCalendarCore::RecurrenceRule*>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::pointerToPython(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_RecurrenceRule_IDX]), cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_KCalendarCore_RecurrenceRulePTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<KCalendarCore::RecurrenceRule*> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::KCalendarCore::RecurrenceRule* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_RecurrenceRule_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_KCalendarCore_RecurrenceRulePTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(Shiboken::Module::get(SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_RecurrenceRule_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_KCalendarCore_RecurrenceRulePTR_;
    return {};
}

// C++ to Python conversion for container type 'QMap<int,QVariant>'.
static PyObject *_QMap_int_QVariant__CppToPython_PyDict(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QMap<int,QVariant> *>(cppIn);
    // TEMPLATE - shiboken_conversion_qmap_to_pydict - START
    PyObject *pyOut = PyDict_New();
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it) {
        const auto &key = it.key();
        const auto &value = it.value();
        PyObject *pyKey = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &key);
        PyObject *pyValue = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QVariant_IDX], &value);
        PyDict_SetItem(pyOut, pyKey, pyValue);
        Py_DECREF(pyKey);
        Py_DECREF(pyValue);
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_qmap_to_pydict - END

}
static void PyDict_PythonToCpp__QMap_int_QVariant_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QMap<int,QVariant> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pydict_to_qmap - START
    PyObject *key{};
    PyObject *value{};
    cppOutRef.clear();
    Py_ssize_t pos = 0;
    while (PyDict_Next(pyIn, &pos, &key, &value)) {
        int cppKey;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter<int>(), key, &(cppKey));
        ::QVariant cppValue;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtCoreTypeConverters[SBK_QVariant_IDX], value, &(cppValue));
        cppOutRef.insert(cppKey, cppValue);
    }
    // TEMPLATE - shiboken_conversion_pydict_to_qmap - END

}
static PythonToCppFunc is_PyDict_PythonToCpp__QMap_int_QVariant__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleDictTypes(Shiboken::Conversions::PrimitiveTypeConverter<int>(), false, SbkPySide6_QtCoreTypeConverters[SBK_QVariant_IDX], false, pyIn))
        return PyDict_PythonToCpp__QMap_int_QVariant_;
    return {};
}

// C++ to Python conversion for container type 'QList<QModelIndex>'.
static PyObject *_QList_QModelIndex__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QModelIndex> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<::QModelIndex>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QModelIndex_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_QModelIndex_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QModelIndex> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::QModelIndex cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QModelIndex_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_QModelIndex__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QModelIndex_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_QModelIndex_;
    return {};
}

// C++ to Python conversion for container type 'QHash<int,QByteArray>'.
static PyObject *_QHash_int_QByteArray__CppToPython_PyDict(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QHash<int,QByteArray> *>(cppIn);
    // TEMPLATE - shiboken_conversion_qmap_to_pydict - START
    PyObject *pyOut = PyDict_New();
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it) {
        const auto &key = it.key();
        const auto &value = it.value();
        PyObject *pyKey = Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<int>(), &key);
        PyObject *pyValue = Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX]), &value);
        PyDict_SetItem(pyOut, pyKey, pyValue);
        Py_DECREF(pyKey);
        Py_DECREF(pyValue);
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_qmap_to_pydict - END

}
static void PyDict_PythonToCpp__QHash_int_QByteArray_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QHash<int,QByteArray> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pydict_to_qmap - START
    PyObject *key{};
    PyObject *value{};
    cppOutRef.clear();
    Py_ssize_t pos = 0;
    while (PyDict_Next(pyIn, &pos, &key, &value)) {
        int cppKey;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter<int>(), key, &(cppKey));
        ::QByteArray cppValue;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX]), value, &(cppValue));
        cppOutRef.insert(cppKey, cppValue);
    }
    // TEMPLATE - shiboken_conversion_pydict_to_qmap - END

}
static PythonToCppFunc is_PyDict_PythonToCpp__QHash_int_QByteArray__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleDictTypes(Shiboken::Conversions::PrimitiveTypeConverter<int>(), false, Shiboken::Object::getConverter(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX])), false, pyIn))
        return PyDict_PythonToCpp__QHash_int_QByteArray_;
    return {};
}

// C++ to Python conversion for container type 'QList<QVariant>'.
static PyObject *_QList_QVariant__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QVariant> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<::QVariant>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QVariant_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_QVariant_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QVariant> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::QVariant cppItem;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtCoreTypeConverters[SBK_QVariant_IDX], pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_QVariant__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtCoreTypeConverters[SBK_QVariant_IDX], pyIn))
        return PySequence_PythonToCpp__QList_QVariant_;
    return {};
}

// C++ to Python conversion for container type 'QList<QString>'.
static PyObject *_QList_QString__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QString> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it, ++idx) {
        ShibokenContainerStdVectorValueType<::QString>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_QString_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QString> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - START
    (cppOutRef).clear();
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    while (true) {
        Shiboken::AutoDecRef pyItem(PyIter_Next(it.object()));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::QString cppItem;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_QString__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], pyIn))
        return PySequence_PythonToCpp__QList_QString_;
    return {};
}

// C++ to Python conversion for container type 'QMap<QString,QVariant>'.
static PyObject *_QMap_QString_QVariant__CppToPython_PyDict(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QMap<QString,QVariant> *>(cppIn);
    // TEMPLATE - shiboken_conversion_qmap_to_pydict - START
    PyObject *pyOut = PyDict_New();
    for (auto it = std::cbegin(cppInRef), end = std::cend(cppInRef); it != end; ++it) {
        const auto &key = it.key();
        const auto &value = it.value();
        PyObject *pyKey = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], &key);
        PyObject *pyValue = Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QVariant_IDX], &value);
        PyDict_SetItem(pyOut, pyKey, pyValue);
        Py_DECREF(pyKey);
        Py_DECREF(pyValue);
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_qmap_to_pydict - END

}
static void PyDict_PythonToCpp__QMap_QString_QVariant_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QMap<QString,QVariant> *>(cppOut);
    // TEMPLATE - shiboken_conversion_pydict_to_qmap - START
    PyObject *key{};
    PyObject *value{};
    cppOutRef.clear();
    Py_ssize_t pos = 0;
    while (PyDict_Next(pyIn, &pos, &key, &value)) {
        ::QString cppKey;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], key, &(cppKey));
        ::QVariant cppValue;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtCoreTypeConverters[SBK_QVariant_IDX], value, &(cppValue));
        cppOutRef.insert(cppKey, cppValue);
    }
    // TEMPLATE - shiboken_conversion_pydict_to_qmap - END

}
static PythonToCppFunc is_PyDict_PythonToCpp__QMap_QString_QVariant__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleDictTypes(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], false, SbkPySide6_QtCoreTypeConverters[SBK_QVariant_IDX], false, pyIn))
        return PyDict_PythonToCpp__QMap_QString_QVariant_;
    return {};
}


// The signatures string for the global functions.
// Multiple signatures have their index "n:" in front.
#if PYSIDE6_COMOPT_COMPRESS == 0
static const char *KCalendarCore_SignatureStrings[] = {
    nullptr}; // Sentinel
#else
static constexpr size_t KCalendarCore_SignatureByteSize = 0;
static constexpr uint8_t KCalendarCore_SignatureBytes[1] = {
    0x00
};
#endif

static void initInheritance()
{
    [[maybe_unused]] auto &bm = Shiboken::BindingManager::instance();
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_RecurrenceRule_RuleObserver_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Recurrence_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Period_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_FreeBusyPeriod_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_CustomProperties_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_IncidenceBase_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_IncidenceBase_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Incidence_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Recurrence_RecurrenceObserver_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Incidence_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Incidence_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Todo_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Incidence_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Journal_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Incidence_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Event_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_IncidenceBase_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_FreeBusy_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QObject_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_CalendarPlugin_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QAbstractListModel_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_CalendarListModel_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QObject_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Calendar_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_CustomProperties_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Calendar_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_IncidenceBase_IncidenceObserver_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Calendar_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Calendar_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_MemoryCalendar_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QObject_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_CalStorage_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_CalStorage_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_FileStorage_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_CalFormat_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_VCalFormat_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_CalFormat_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_ICalFormat_IDX]);
    bm.addClassInheritance(&SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_CustomProperties_IDX],
                           &SbkKCalendarCoreTypeStructs[SBK_KCalendarCore_Alarm_IDX]);
}

static void initTypes_KCalendarCore(PyObject *module)
{
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCoreKCalendarCore);
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Visitor, "KCalendarCore.Visitor");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCoreKCalendarCore_Todos, "KCalendarCore.Todos");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_ScheduleMessage, "KCalendarCore.ScheduleMessage");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_RecurrenceRule, "KCalendarCore.RecurrenceRule");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_RecurrenceRule_RuleObserver, "KCalendarCore.RecurrenceRule.RuleObserver");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Recurrence, "KCalendarCore.Recurrence");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Recurrence_RecurrenceObserver, "KCalendarCore.Recurrence.RecurrenceObserver");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Person, "KCalendarCore.Person");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Period, "KCalendarCore.Period");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_OccurrenceIterator, "KCalendarCore.OccurrenceIterator");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCoreKCalendarCore_Journals, "KCalendarCore.Journals");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCoreKCalendarCore_Incidences, "KCalendarCore.Incidences");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_FreeBusyPeriod, "KCalendarCore.FreeBusyPeriod");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_FreeBusyCache, "KCalendarCore.FreeBusyCache");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Exception, "KCalendarCore.Exception");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCoreKCalendarCore_Events, "KCalendarCore.Events");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Duration, "KCalendarCore.Duration");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_CustomProperties, "KCalendarCore.CustomProperties");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_IncidenceBase, "KCalendarCore.IncidenceBase");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_IncidenceBase_IncidenceObserver, "KCalendarCore.IncidenceBase.IncidenceObserver");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Incidence, "KCalendarCore.Incidence");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Todo, "KCalendarCore.Todo");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Journal, "KCalendarCore.Journal");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Event, "KCalendarCore.Event");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_FreeBusy, "KCalendarCore.FreeBusy");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Conference, "KCalendarCore.Conference");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_CalendarPluginLoader, "KCalendarCore.CalendarPluginLoader");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_CalendarPlugin, "KCalendarCore.CalendarPlugin");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_CalendarListModel, "KCalendarCore.CalendarListModel");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Calendar, "KCalendarCore.Calendar");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_MemoryCalendar, "KCalendarCore.MemoryCalendar");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_CalStorage, "KCalendarCore.CalStorage");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_FileStorage, "KCalendarCore.FileStorage");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_CalFormat, "KCalendarCore.CalFormat");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_VCalFormat, "KCalendarCore.VCalFormat");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_ICalFormat, "KCalendarCore.ICalFormat");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_CalFilter, "KCalendarCore.CalFilter");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Attendee, "KCalendarCore.Attendee");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Attachment, "KCalendarCore.Attachment");
    Shiboken::Module::AddTypeCreationFunction(module, "KCalendarCore", init_KCalendarCore_Alarm, "KCalendarCore.Alarm");
}

static void initConverters_KCalendarCore()
{
    // Register primitive types converters.
    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "QRgb");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__blkcnt64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__blkcnt_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__blksize_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<char>(), "__caddr_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__clock_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<int>(), "__clockid_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<int>(), "__compar_d_fn_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<int>(), "__compar_fn_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<int>(), "__daddr_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__dev_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__fsblkcnt64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__fsblkcnt_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__fsfilcnt64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__fsfilcnt_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__fsword_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "__gid_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "__id_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__ino64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__ino_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<short>(), "__int16_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<int>(), "__int32_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__int64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<signed char>(), "__int8_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<short>(), "__int_least16_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<int>(), "__int_least32_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__int_least64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<signed char>(), "__int_least8_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__intmax_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__intptr_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<int>(), "__key_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__loff_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "__mode_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__nlink_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__off64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__off_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<int>(), "__pid_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "__poll_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__quad_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__rlim64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__rlim_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<int>(), "__sig_atomic_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "__socklen_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__ssize_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__suseconds64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__suseconds_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__syscall_slong_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__syscall_ulong_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "__time_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned char>(), "__u_char");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "__u_int");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__u_long");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__u_quad_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned short>(), "__u_short");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "__uid_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned short>(), "__uint16_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "__uint32_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__uint64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned char>(), "__uint8_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned short>(), "__uint_least16_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "__uint_least32_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__uint_least64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned char>(), "__uint_least8_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "__uintmax_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "__useconds_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "blkcnt64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "blkcnt_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "blksize_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<char>(), "caddr_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<int>(), "comparison_fn_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<int>(), "daddr_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "dev_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "fsblkcnt64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "fsblkcnt_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "fsfilcnt64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "fsfilcnt_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "gid_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "id_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "ino64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "ino_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "int_fast16_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "int_fast32_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "int_fast64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<signed char>(), "int_fast8_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "intmax_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<int>(), "key_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "loff_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "mode_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "nlink_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "off64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "off_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<int>(), "pid_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<bool>(), "qInternalCallback");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "quad_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "register_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "ssize_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<long>(), "suseconds_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned char>(), "u_char");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "u_int");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned short>(), "u_int16_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "u_int32_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "u_int64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned char>(), "u_int8_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "u_long");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "u_quad_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned short>(), "u_short");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "uid_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "uint_fast16_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "uint_fast32_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "uint_fast64_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned char>(), "uint_fast8_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned long>(), "uintmax_t");

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<unsigned int>(), "useconds_t");

}

static void initContainerConverters_KCalendarCore()
{
    // Register converter for type 'QList<int>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_int_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_int__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_int_IDX], "QList<int>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_int_IDX],
        PySequence_PythonToCpp__QList_int_,
        is_PySequence_PythonToCpp__QList_int__Convertible);
    Shiboken::Conversions::setPythonToCppPointerFunctions(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_int_IDX],
        PythonToCppQIntList,
        isQIntListPythonToCppConvertible);

    // Register converter for type 'QList<KCalendarCore::Person>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Person_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_KCalendarCore_Person__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Person_IDX], "QList<KCalendarCore::Person>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Person_IDX],
        PySequence_PythonToCpp__QList_KCalendarCore_Person_,
        is_PySequence_PythonToCpp__QList_KCalendarCore_Person__Convertible);
    // Register converters for type aliases of QList<KCalendarCore::Person>'.
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Person_IDX], "KCalendarCore::Person::List");

    // Register converter for type 'QList<QDateTime>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QDateTime_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QDateTime__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QDateTime_IDX], "QList<QDateTime>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QDateTime_IDX],
        PySequence_PythonToCpp__QList_QDateTime_,
        is_PySequence_PythonToCpp__QList_QDateTime__Convertible);
    // Register converters for type aliases of QList<QDateTime>'.
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QDateTime_IDX], "KCalendarCore::DateTimeList");

    // Register converter for type 'QList<KCalendarCore::Attachment>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Attachment_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_KCalendarCore_Attachment__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Attachment_IDX], "QList<KCalendarCore::Attachment>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Attachment_IDX],
        PySequence_PythonToCpp__QList_KCalendarCore_Attachment_,
        is_PySequence_PythonToCpp__QList_KCalendarCore_Attachment__Convertible);
    // Register converters for type aliases of QList<KCalendarCore::Attachment>'.
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Attachment_IDX], "KCalendarCore::Attachment::List");

    // Register converter for type 'QList<KCalendarCore::Conference>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Conference_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_KCalendarCore_Conference__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Conference_IDX], "QList<KCalendarCore::Conference>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Conference_IDX],
        PySequence_PythonToCpp__QList_KCalendarCore_Conference_,
        is_PySequence_PythonToCpp__QList_KCalendarCore_Conference__Convertible);
    // Register converters for type aliases of QList<KCalendarCore::Conference>'.
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Conference_IDX], "KCalendarCore::Conference::List");

    // Register converter for type 'QList<KCalendarCore::FreeBusyPeriod>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_FreeBusyPeriod_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_KCalendarCore_FreeBusyPeriod__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_FreeBusyPeriod_IDX], "QList<KCalendarCore::FreeBusyPeriod>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_FreeBusyPeriod_IDX],
        PySequence_PythonToCpp__QList_KCalendarCore_FreeBusyPeriod_,
        is_PySequence_PythonToCpp__QList_KCalendarCore_FreeBusyPeriod__Convertible);
    // Register converters for type aliases of QList<KCalendarCore::FreeBusyPeriod>'.
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_FreeBusyPeriod_IDX], "KCalendarCore::FreeBusyPeriod::List");

    // Register converter for type 'QList<KCalendarCore::Period>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Period_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_KCalendarCore_Period__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Period_IDX], "QList<KCalendarCore::Period>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Period_IDX],
        PySequence_PythonToCpp__QList_KCalendarCore_Period_,
        is_PySequence_PythonToCpp__QList_KCalendarCore_Period__Convertible);
    // Register converters for type aliases of QList<KCalendarCore::Period>'.
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Period_IDX], "KCalendarCore::Period::List");

    // Register converter for type 'QList<KCalendarCore::Attendee>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Attendee_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_KCalendarCore_Attendee__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Attendee_IDX], "QList<KCalendarCore::Attendee>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Attendee_IDX],
        PySequence_PythonToCpp__QList_KCalendarCore_Attendee_,
        is_PySequence_PythonToCpp__QList_KCalendarCore_Attendee__Convertible);
    // Register converters for type aliases of QList<KCalendarCore::Attendee>'.
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_Attendee_IDX], "KCalendarCore::Attendee::List");

    // Register converter for type 'QSet<KCalendarCore::IncidenceBase::Field>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QSet_KCalendarCore_IncidenceBase_Field_IDX] = Shiboken::Conversions::createConverter(&PySet_Type, _QSet_KCalendarCore_IncidenceBase_Field__CppToPython_PySet);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QSet_KCalendarCore_IncidenceBase_Field_IDX], "QSet<KCalendarCore::IncidenceBase::Field>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QSet_KCalendarCore_IncidenceBase_Field_IDX],
        PySequence_PythonToCpp__QSet_KCalendarCore_IncidenceBase_Field_,
        is_PySequence_PythonToCpp__QSet_KCalendarCore_IncidenceBase_Field__Convertible);

    // Register converter for type 'QMap<QByteArray,QString>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QMap_QByteArray_QString_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QMap_QByteArray_QString__CppToPython_PyDict);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QMap_QByteArray_QString_IDX], "QMap<QByteArray,QString>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QMap_QByteArray_QString_IDX],
        PyDict_PythonToCpp__QMap_QByteArray_QString_,
        is_PyDict_PythonToCpp__QMap_QByteArray_QString__Convertible);

    // Register converter for type 'QList<QTime>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QTime_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QTime__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QTime_IDX], "QList<QTime>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QTime_IDX],
        PySequence_PythonToCpp__QList_QTime_,
        is_PySequence_PythonToCpp__QList_QTime__Convertible);
    // Register converters for type aliases of QList<QTime>'.
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QTime_IDX], "KCalendarCore::TimeList");

    // Register converter for type 'QList<QDate>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QDate_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QDate__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QDate_IDX], "QList<QDate>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QDate_IDX],
        PySequence_PythonToCpp__QList_QDate_,
        is_PySequence_PythonToCpp__QList_QDate__Convertible);
    // Register converters for type aliases of QList<QDate>'.
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QDate_IDX], "KCalendarCore::DateList");
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QDate_IDX], "KCalendarCore::DateList");

    // Register converter for type 'QList<KCalendarCore::RecurrenceRule*>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_RecurrenceRulePTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_KCalendarCore_RecurrenceRulePTR__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_RecurrenceRulePTR_IDX], "QList<KCalendarCore::RecurrenceRule*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_RecurrenceRulePTR_IDX],
        PySequence_PythonToCpp__QList_KCalendarCore_RecurrenceRulePTR_,
        is_PySequence_PythonToCpp__QList_KCalendarCore_RecurrenceRulePTR__Convertible);
    // Register converters for type aliases of QList<KCalendarCore::RecurrenceRule*>'.
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_KCalendarCore_RecurrenceRulePTR_IDX], "KCalendarCore::RecurrenceRule::List");

    // Register converter for type 'QMap<int,QVariant>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QMap_int_QVariant_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QMap_int_QVariant__CppToPython_PyDict);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QMap_int_QVariant_IDX], "QMap<int,QVariant>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QMap_int_QVariant_IDX],
        PyDict_PythonToCpp__QMap_int_QVariant_,
        is_PyDict_PythonToCpp__QMap_int_QVariant__Convertible);

    // Register converter for type 'QList<QModelIndex>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QModelIndex_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QModelIndex__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QModelIndex_IDX], "QList<QModelIndex>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QModelIndex_IDX],
        PySequence_PythonToCpp__QList_QModelIndex_,
        is_PySequence_PythonToCpp__QList_QModelIndex__Convertible);
    // Register converters for type aliases of QList<QModelIndex>'.
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QModelIndex_IDX], "QModelIndexList");

    // Register converter for type 'QHash<int,QByteArray>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QHash_int_QByteArray_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QHash_int_QByteArray__CppToPython_PyDict);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QHash_int_QByteArray_IDX], "QHash<int,QByteArray>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QHash_int_QByteArray_IDX],
        PyDict_PythonToCpp__QHash_int_QByteArray_,
        is_PyDict_PythonToCpp__QHash_int_QByteArray__Convertible);

    // Register converter for type 'QList<QVariant>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QVariant_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QVariant__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QVariant_IDX], "QList<QVariant>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QVariant_IDX],
        PySequence_PythonToCpp__QList_QVariant_,
        is_PySequence_PythonToCpp__QList_QVariant__Convertible);
    // Register converters for type aliases of QList<QVariant>'.
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QVariant_IDX], "QVariantList");

    // Register converter for type 'QList<QString>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QString_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QString__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QString_IDX], "QList<QString>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QList_QString_IDX],
        PySequence_PythonToCpp__QList_QString_,
        is_PySequence_PythonToCpp__QList_QString__Convertible);
    // Register converters for type aliases of QList<QString>'.

    // Register converter for type 'QMap<QString,QVariant>'.
    SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QMap_QString_QVariant_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QMap_QString_QVariant__CppToPython_PyDict);
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QMap_QString_QVariant_IDX], "QMap<QString,QVariant>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QMap_QString_QVariant_IDX],
        PyDict_PythonToCpp__QMap_QString_QVariant_,
        is_PyDict_PythonToCpp__QMap_QString_QVariant__Convertible);
    // Register converters for type aliases of QMap<QString,QVariant>'.
    Shiboken::Conversions::registerConverterName(SbkKCalendarCoreTypeConverters[SBK_KCalendarCore_QMap_QString_QVariant_IDX], "QVariantMap");

}

static void registerOpaqueContainers_KCalendarCore(PyObject *module)
{
    PyTypeObject *pyType{};
    auto *qVariantConverter = Shiboken::Conversions::getConverter("QVariant");
    Q_ASSERT(qVariantConverter != nullptr);
    pyType = QIntList_TypeF();
    Py_XINCREF(reinterpret_cast<PyObject *>(pyType));
    PepModule_AddType(module, pyType);
    if constexpr (QMetaTypeId2<int>::Defined) {
        Shiboken::Conversions::prependPythonToCppValueConversion(qVariantConverter,
            PythonToQVariantQIntList, isQIntListPythonToQVariantConvertible);
    }
}

// Create an array of wrapper types/names for the current module.
static Shiboken::Module::TypeInitStruct cppApi[] = {
    {nullptr, "KCalendarCore.KCalendarCore"},
    {nullptr, "KCalendarCore.KCalendarCore.AccessMode"},
    {nullptr, "KCalendarCore.KCalendarCore.Alarm"},
    {nullptr, "KCalendarCore.KCalendarCore.Alarm.Type"},
    {nullptr, "KCalendarCore.KCalendarCore.Attachment"},
    {nullptr, "KCalendarCore.KCalendarCore.Attendee"},
    {nullptr, "KCalendarCore.KCalendarCore.Attendee.CuType"},
    {nullptr, "KCalendarCore.KCalendarCore.Attendee.PartStat"},
    {nullptr, "KCalendarCore.KCalendarCore.Attendee.Role"},
    {nullptr, "KCalendarCore.KCalendarCore.CalFilter"},
    {nullptr, "KCalendarCore.KCalendarCore.CalFilter.Criteria"},
    {nullptr, "KCalendarCore.KCalendarCore.CalFormat"},
    {nullptr, "KCalendarCore.KCalendarCore.CalStorage"},
    {nullptr, "KCalendarCore.KCalendarCore.Calendar"},
    {nullptr, "KCalendarCore.KCalendarCore.CalendarListModel"},
    {nullptr, "KCalendarCore.KCalendarCore.CalendarListModel.Role"},
    {nullptr, "KCalendarCore.KCalendarCore.CalendarPlugin"},
    {nullptr, "KCalendarCore.KCalendarCore.CalendarPluginLoader"},
    {nullptr, "KCalendarCore.KCalendarCore.Conference"},
    {nullptr, "KCalendarCore.KCalendarCore.CustomProperties"},
    {nullptr, "KCalendarCore.KCalendarCore.Duration"},
    {nullptr, "KCalendarCore.KCalendarCore.Duration.Type"},
    {nullptr, "KCalendarCore.KCalendarCore.Event"},
    {nullptr, "KCalendarCore.KCalendarCore.Event.Transparency"},
    {nullptr, "KCalendarCore.KCalendarCore.EventSortField"},
    {nullptr, "KCalendarCore.KCalendarCore.Events"},
    {nullptr, "KCalendarCore.KCalendarCore.Exception"},
    {nullptr, "KCalendarCore.KCalendarCore.Exception.ErrorCode"},
    {nullptr, "KCalendarCore.KCalendarCore.FileStorage"},
    {nullptr, "KCalendarCore.KCalendarCore.FreeBusy"},
    {nullptr, "KCalendarCore.KCalendarCore.FreeBusyCache"},
    {nullptr, "KCalendarCore.KCalendarCore.FreeBusyPeriod"},
    {nullptr, "KCalendarCore.KCalendarCore.FreeBusyPeriod.FreeBusyType"},
    {nullptr, "KCalendarCore.KCalendarCore.ICalFormat"},
    {nullptr, "KCalendarCore.KCalendarCore.Incidence"},
    {nullptr, "KCalendarCore.KCalendarCore.Incidence.RelType"},
    {nullptr, "KCalendarCore.KCalendarCore.Incidence.Secrecy"},
    {nullptr, "KCalendarCore.KCalendarCore.Incidence.Status"},
    {nullptr, "KCalendarCore.KCalendarCore.IncidenceBase"},
    {nullptr, "KCalendarCore.KCalendarCore.IncidenceBase.DateTimeRole"},
    {nullptr, "KCalendarCore.KCalendarCore.IncidenceBase.Field"},
    {nullptr, "KCalendarCore.KCalendarCore.IncidenceBase.IncidenceObserver"},
    {nullptr, "KCalendarCore.KCalendarCore.IncidenceBase.IncidenceType"},
    {nullptr, "KCalendarCore.KCalendarCore.IncidenceBase.VirtualHook"},
    {nullptr, "KCalendarCore.KCalendarCore.Incidences"},
    {nullptr, "KCalendarCore.KCalendarCore.Journal"},
    {nullptr, "KCalendarCore.KCalendarCore.JournalSortField"},
    {nullptr, "KCalendarCore.KCalendarCore.Journals"},
    {nullptr, "KCalendarCore.KCalendarCore.MemoryCalendar"},
    {nullptr, "KCalendarCore.KCalendarCore.OccurrenceIterator"},
    {nullptr, "KCalendarCore.KCalendarCore.Period"},
    {nullptr, "KCalendarCore.KCalendarCore.Person"},
    {nullptr, "KCalendarCore.KCalendarCore.Recurrence"},
    {nullptr, "KCalendarCore.KCalendarCore.Recurrence.RecurrenceObserver"},
    {nullptr, "KCalendarCore.KCalendarCore.RecurrenceRule"},
    {nullptr, "KCalendarCore.KCalendarCore.RecurrenceRule.PeriodType"},
    {nullptr, "KCalendarCore.KCalendarCore.RecurrenceRule.RuleObserver"},
    {nullptr, "KCalendarCore.KCalendarCore.ScheduleMessage"},
    {nullptr, "KCalendarCore.KCalendarCore.ScheduleMessage.Status"},
    {nullptr, "KCalendarCore.KCalendarCore.SortDirection"},
    {nullptr, "KCalendarCore.KCalendarCore.Todo"},
    {nullptr, "KCalendarCore.KCalendarCore.TodoSortField"},
    {nullptr, "KCalendarCore.KCalendarCore.Todos"},
    {nullptr, "KCalendarCore.KCalendarCore.VCalFormat"},
    {nullptr, "KCalendarCore.KCalendarCore.Visitor"},
    {nullptr, "KCalendarCore.KCalendarCore.iTIPMethod"},
    {nullptr, nullptr}
};

// Create an array of primitive type converters for the current module.
static SbkConverter *sbkConverters[SBK_KCalendarCore_CONVERTERS_IDX_COUNT];

extern "C" {
static int exec_KCalendarCore(PyObject *module)
{
    Shiboken::Module::exec(module);

    // Initialize classes in the type system
    initTypes_KCalendarCore(module);

    registerOpaqueContainers_KCalendarCore(module);

    Shiboken::Module::registerTypes(module, SbkKCalendarCoreTypeStructs);
    Shiboken::Module::registerTypeConverters(module, SbkKCalendarCoreTypeConverters);

    initInheritance();

    if (Shiboken::Errors::occurred() != nullptr) {
        PyErr_Print();
        Py_FatalError("shiboken: can't initialize module KCalendarCore");
    }
    PySide::registerCleanupFunction(cleanTypesAttributes);

#if PYSIDE6_COMOPT_COMPRESS == 0
    FinishSignatureInitialization(module, KCalendarCore_SignatureStrings);
#else
    if (FinishSignatureInitBytes(module, KCalendarCore_SignatureBytes, KCalendarCore_SignatureByteSize) < 0)
        return -1;
#endif

    return 0;
}
} // extern "C"

static PyModuleDef_Slot KCalendarCoreModuleSlots[] = {
    {Py_mod_exec, reinterpret_cast<void *>(exec_KCalendarCore)},
#if !defined(PYPY_VERSION) && ((!defined(Py_LIMITED_API) && PY_VERSION_HEX >= 0x030C0000) || (defined(Py_LIMITED_API) && Py_LIMITED_API >= 0x030C0000))
    {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED},
#endif
#ifdef Py_GIL_DISABLED
    {Py_mod_gil, Py_MOD_GIL_USED},
#endif
    {0, nullptr}
};

static struct PyModuleDef KCalendarCoreModuleDef = {
    /* m_base     */ PyModuleDef_HEAD_INIT,
    /* m_name     */ "KCalendarCore",
    /* m_doc      */ nullptr,
    /* m_size     */ 0,
    /* m_methods  */ KCalendarCoreMethods,
    /* m_slots    */ KCalendarCoreModuleSlots,
    /* m_traverse */ nullptr,
    /* m_clear    */ nullptr,
    /* m_free     */ nullptr
};

extern "C" LIBSHIBOKEN_EXPORT PyObject *PyInit_KCalendarCore()
{
    Shiboken::init();

    // The global structure consisting of (type, name) pairs.
    SbkKCalendarCoreTypeStructs = cppApi;

    SbkKCalendarCoreTypeConverters = sbkConverters;

    {
        Shiboken::AutoDecRef requiredModule(Shiboken::Module::import("PySide6.QtCore"));
        if (requiredModule.isNull())
            return nullptr;
        SbkPySide6_QtCoreTypeStructs = Shiboken::Module::getTypes(requiredModule);
        SbkPySide6_QtCoreTypeConverters = Shiboken::Module::getTypeConverters(requiredModule);
    }

    {
        Shiboken::AutoDecRef requiredModule(Shiboken::Module::import("PySide6.QtGui"));
        if (requiredModule.isNull())
            return nullptr;
        SbkPySide6_QtGuiTypeStructs = Shiboken::Module::getTypes(requiredModule);
        SbkPySide6_QtGuiTypeConverters = Shiboken::Module::getTypeConverters(requiredModule);
    }

    initConverters_KCalendarCore();
    initContainerConverters_KCalendarCore();

    PyObject *module = nullptr;
    if (Shiboken::isCompiled()) {
        KCalendarCoreModuleDef.m_size = -1;
        KCalendarCoreModuleDef.m_slots = nullptr;
        module = Shiboken::Module::createOnly("KCalendarCore", &KCalendarCoreModuleDef);
        if (module == nullptr)
            return nullptr;
#ifdef Py_GIL_DISABLED
        PyUnstable_Module_SetGIL(module, Py_MOD_GIL_NOT_USED);
#endif
        if (exec_KCalendarCore(module) != 0)
            return nullptr;
    } else {
        module = PyModuleDef_Init(&KCalendarCoreModuleDef);
    }
    return module;
}

