
#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 "akonadicore_python.h"

#include <QHash>
#include <QList>
#include <QMap>
#include <QSet>
#include <QString>
#include <agentinstance.h>
#include <agenttype.h>
#include <attribute.h>
#include <collection.h>
#include <item.h>
#include <monitor.h>
#include <qabstractitemmodel.h>
#include <qbytearray.h>
#include <qurl.h>
#include <qvariant.h>
#include <searchquery.h>
#include <tag.h>


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

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

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

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

// Classes initialization functions ------------------------------------------------------------
PyTypeObject *init_AkonadiCoreAkonadi(PyObject *enclosing);
PyTypeObject *init_AkonadiCoreAkonadi_TrashSettings(PyObject *enclosing);
PyTypeObject *init_Akonadi_TrashFilterProxyModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_TagModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_TagFetchScope(PyObject *enclosing);
PyTypeObject *init_Akonadi_TagCache(PyObject *enclosing);
PyTypeObject *init_Akonadi_Tag(PyObject *enclosing);
PyTypeObject *init_Akonadi_TagStaticFields(PyObject *module);
PyTypeObject *init_Akonadi_StatisticsProxyModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_SpecialCollectionsDiscoveryJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_SpecialCollections(PyObject *enclosing);
PyTypeObject *init_Akonadi_Session(PyObject *enclosing);
PyTypeObject *init_Akonadi_ServerManager(PyObject *enclosing);
PyTypeObject *init_Akonadi_SelectionProxyModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_SearchTerm(PyObject *enclosing);
PyTypeObject *init_Akonadi_SearchQuery(PyObject *enclosing);
PyTypeObject *init_Akonadi_ResourceSynchronizationJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_RecursiveItemFetchJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_RecursiveCollectionFilterProxyModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_PartFetcher(PyObject *enclosing);
PyTypeObject *init_Akonadi_NotificationSubscriber(PyObject *enclosing);
PyTypeObject *init_Akonadi_Monitor(PyObject *enclosing);
PyTypeObject *init_Akonadi_MimeTypeChecker(PyObject *enclosing);
PyTypeObject *init_Akonadi_Job(PyObject *enclosing);
PyTypeObject *init_Akonadi_TrashRestoreJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_TrashJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_TransactionSequence(PyObject *enclosing);
PyTypeObject *init_Akonadi_SpecialCollectionsRequestJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_TransactionJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_TagModifyJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_TagFetchJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_TagDeleteJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_TagCreateJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_SearchCreateJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_ItemSync(PyObject *enclosing);
PyTypeObject *init_Akonadi_ItemSearchJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_ItemMoveJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_ItemMonitor(PyObject *enclosing);
PyTypeObject *init_Akonadi_ItemModifyJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_ItemFetchScope(PyObject *enclosing);
PyTypeObject *init_Akonadi_ItemFetchJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_ItemDeleteJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_ItemCreateJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_ItemCopyJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_Item(PyObject *enclosing);
PyTypeObject *init_Akonadi_ItemStaticFields(PyObject *module);
PyTypeObject *init_Akonadi_GidExtractorInterface(PyObject *enclosing);
PyTypeObject *init_Akonadi_FavoriteCollectionsModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_Exception(PyObject *enclosing);
PyTypeObject *init_Akonadi_EntityTreeModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_EntityRightsFilterModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_EntityOrderProxyModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_EntityMimeTypeFilterModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_DifferencesAlgorithmInterface(PyObject *enclosing);
PyTypeObject *init_Akonadi_Control(PyObject *enclosing);
PyTypeObject *init_AkonadiCoreAkonadi_CollectionUtils(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionStatisticsJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionStatistics(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionPathResolver(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionMoveJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionModifyJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionFilterProxyModel(PyObject *enclosing);
PyTypeObject *init_ColorProxyModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionFetchScope(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionFetchJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionDeleteJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionCreateJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionCopyJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionAttributesSynchronizationJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_Collection(PyObject *enclosing);
PyTypeObject *init_Akonadi_ChangeRecorder(PyObject *enclosing);
PyTypeObject *init_Akonadi_ChangeNotification(PyObject *enclosing);
PyTypeObject *init_Akonadi_CachePolicy(PyObject *enclosing);
PyTypeObject *init_Akonadi_AttributeFactory(PyObject *enclosing);
PyTypeObject *init_Akonadi_Attribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_TagAttribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_SpecialCollectionAttribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_PersistentSearchAttribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_IndexPolicyAttribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_FavoriteCollectionAttribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_EntityHiddenAttribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_EntityDisplayAttribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_EntityDeletedAttribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_EntityAnnotationsAttribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionQuotaAttribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionIdentificationAttribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionColorAttribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_CollectionAnnotationsAttribute(PyObject *enclosing);
PyTypeObject *init_Akonadi_AgentTypeModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_AgentType(PyObject *enclosing);
PyTypeObject *init_Akonadi_AgentManager(PyObject *enclosing);
PyTypeObject *init_Akonadi_AgentInstanceModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_AgentInstanceFilterProxyModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_AgentInstanceCreateJob(PyObject *enclosing);
PyTypeObject *init_Akonadi_AgentInstance(PyObject *enclosing);
PyTypeObject *init_Akonadi_AgentFilterProxyModel(PyObject *enclosing);
PyTypeObject *init_Akonadi_AgentConfigurationBase(PyObject *enclosing);
PyTypeObject *init_Akonadi_AccountActivitiesAbstract(PyObject *enclosing);
PyTypeObject *init_Akonadi_AbstractDifferencesReporter(PyObject *enclosing);

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

// 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:AkonadiCore.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 '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 'QMap<QByteArray,QByteArray>'.
static PyObject *_QMap_QByteArray_QByteArray__CppToPython_PyDict(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QMap<QByteArray,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::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX]), &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__QMap_QByteArray_QByteArray_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QMap<QByteArray,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)) {
        ::QByteArray cppKey;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX]), 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__QMap_QByteArray_QByteArray__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleDictTypes(Shiboken::Object::getConverter(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX])), false, Shiboken::Object::getConverter(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX])), false, pyIn))
        return PyDict_PythonToCpp__QMap_QByteArray_QByteArray_;
    return {};
}

// C++ to Python conversion for container type 'QList<qint64>'.
static PyObject *_QList_qint64__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<qint64> *>(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<qint64>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<qint64>(), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_qint64_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<qint64> *>(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;
        }
        qint64 cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter<qint64>(), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_qint64__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Conversions::PrimitiveTypeConverter<qint64>(), pyIn))
        return PySequence_PythonToCpp__QList_qint64_;
    return {};
}

// C++ to Python conversion for container type 'QList<Akonadi::Collection>'.
static PyObject *_QList_Akonadi_Collection__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Akonadi::Collection> *>(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<::Akonadi::Collection>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Collection_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_Akonadi_Collection_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Akonadi::Collection> *>(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;
        }
        ::Akonadi::Collection cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Collection_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_Akonadi_Collection__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Collection_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_Akonadi_Collection_;
    return {};
}

// C++ to Python conversion for container type 'QList<Akonadi::Attribute*>'.
static PyObject *_QList_Akonadi_AttributePTR__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Akonadi::Attribute*> *>(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<::Akonadi::Attribute*>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::pointerToPython(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX]), cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_Akonadi_AttributePTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Akonadi::Attribute*> *>(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;
        }
        ::Akonadi::Attribute* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_Akonadi_AttributePTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_Akonadi_AttributePTR_;
    return {};
}

// C++ to Python conversion for container type 'QSet<QByteArray>'.
static PyObject *_QSet_QByteArray__CppToPython_PySet(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QSet<QByteArray> *>(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::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pyset - END

}
static void PySequence_PythonToCpp__QSet_QByteArray_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QSet<QByteArray> *>(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;
        }
        ::QByteArray cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX]), pyItem, &(cppItem));
        (cppOutRef).insert(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsetcontainer - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QSet_QByteArray__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleIterableTypes(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX]), pyIn))
        return PySequence_PythonToCpp__QSet_QByteArray_;
    return {};
}

// C++ to Python conversion for container type 'QList<long long>'.
static PyObject *_QList_longlong__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<long long> *>(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<long long>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Conversions::PrimitiveTypeConverter<long long>(), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_longlong_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<long long> *>(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;
        }
        long long cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter<long long>(), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_longlong__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Conversions::PrimitiveTypeConverter<long long>(), pyIn))
        return PySequence_PythonToCpp__QList_longlong_;
    return {};
}

// C++ to Python conversion for container type 'QList<Akonadi::Item>'.
static PyObject *_QList_Akonadi_Item__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Akonadi::Item> *>(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<::Akonadi::Item>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Item_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_Akonadi_Item_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Akonadi::Item> *>(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;
        }
        ::Akonadi::Item cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Item_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_Akonadi_Item__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Item_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_Akonadi_Item_;
    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 {};
}

// 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<QByteArray>'.
static PyObject *_QList_QByteArray__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QByteArray> *>(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<::QByteArray>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_QByteArray_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QByteArray> *>(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;
        }
        ::QByteArray cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_QByteArray__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QByteArray_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_QByteArray_;
    return {};
}

// C++ to Python conversion for container type 'QList<Akonadi::Tag>'.
static PyObject *_QList_Akonadi_Tag__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Akonadi::Tag> *>(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<::Akonadi::Tag>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Tag_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_Akonadi_Tag_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Akonadi::Tag> *>(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;
        }
        ::Akonadi::Tag cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Tag_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_Akonadi_Tag__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Tag_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_Akonadi_Tag_;
    return {};
}

// C++ to Python conversion for container type 'QList<QUrl>'.
static PyObject *_QList_QUrl__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QUrl> *>(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<::QUrl>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QUrl_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_QUrl_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QUrl> *>(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;
        }
        ::QUrl cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QUrl_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_QUrl__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkPySide6_QtCoreTypeStructs[SBK_QUrl_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_QUrl_;
    return {};
}

// C++ to Python conversion for container type 'QList<Akonadi::AgentInstance>'.
static PyObject *_QList_Akonadi_AgentInstance__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Akonadi::AgentInstance> *>(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<::Akonadi::AgentInstance>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_AgentInstance_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_Akonadi_AgentInstance_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Akonadi::AgentInstance> *>(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;
        }
        ::Akonadi::AgentInstance cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_AgentInstance_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_Akonadi_AgentInstance__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_AgentInstance_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_Akonadi_AgentInstance_;
    return {};
}

// C++ to Python conversion for container type 'QList<Akonadi::AgentType>'.
static PyObject *_QList_Akonadi_AgentType__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Akonadi::AgentType> *>(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<::Akonadi::AgentType>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_AgentType_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_Akonadi_AgentType_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Akonadi::AgentType> *>(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;
        }
        ::Akonadi::AgentType cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_AgentType_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_Akonadi_AgentType__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_AgentType_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_Akonadi_AgentType_;
    return {};
}

// C++ to Python conversion for container type 'QSet<Akonadi::Tag>'.
static PyObject *_QSet_Akonadi_Tag__CppToPython_PySet(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QSet<Akonadi::Tag> *>(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::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Tag_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pyset - END

}
static void PySequence_PythonToCpp__QSet_Akonadi_Tag_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QSet<Akonadi::Tag> *>(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;
        }
        ::Akonadi::Tag cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Tag_IDX]), pyItem, &(cppItem));
        (cppOutRef).insert(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsetcontainer - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QSet_Akonadi_Tag__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleIterableTypes(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Tag_IDX]), pyIn))
        return PySequence_PythonToCpp__QSet_Akonadi_Tag_;
    return {};
}

// C++ to Python conversion for container type 'QList<Akonadi::Monitor::Type>'.
static PyObject *_QList_Akonadi_Monitor_Type__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Akonadi::Monitor::Type> *>(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<::Akonadi::Monitor::Type>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Enum::getConverter(reinterpret_cast<SbkEnumType *>(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Monitor_Type_IDX]))), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_Akonadi_Monitor_Type_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Akonadi::Monitor::Type> *>(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;
        }
        ::Akonadi::Monitor::Type cppItem = static_cast< ::Akonadi::Monitor::Type>(0);
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Enum::getConverter(reinterpret_cast<SbkEnumType *>(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Monitor_Type_IDX]))), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_Akonadi_Monitor_Type__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Enum::getConverter(reinterpret_cast<SbkEnumType *>(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Monitor_Type_IDX]))), pyIn))
        return PySequence_PythonToCpp__QList_Akonadi_Monitor_Type_;
    return {};
}

// C++ to Python conversion for container type 'QSet<qint64>'.
static PyObject *_QSet_qint64__CppToPython_PySet(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QSet<qint64> *>(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::Conversions::PrimitiveTypeConverter<qint64>(), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pyset - END

}
static void PySequence_PythonToCpp__QSet_qint64_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QSet<qint64> *>(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;
        }
        qint64 cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter<qint64>(), pyItem, &(cppItem));
        (cppOutRef).insert(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsetcontainer - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QSet_qint64__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleIterableTypes(Shiboken::Conversions::PrimitiveTypeConverter<qint64>(), pyIn))
        return PySequence_PythonToCpp__QSet_qint64_;
    return {};
}

// C++ to Python conversion for container type 'QSet<QString>'.
static PyObject *_QSet_QString__CppToPython_PySet(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QSet<QString> *>(cppIn);
    // TEMPLATE - shiboken_conversion_cppsequence_to_pyset - START
    PyObject *pyOut = PySet_New(nullptr);
    for (const auto &cppItem : cppInRef) {
        PySet_Add(pyOut, Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pyset - END

}
static void PySequence_PythonToCpp__QSet_QString_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QSet<QString> *>(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;
        }
        ::QString cppItem;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], pyItem, &(cppItem));
        (cppOutRef).insert(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsetcontainer - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QSet_QString__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleIterableTypes(SbkPySide6_QtCoreTypeConverters[SBK_QString_IDX], pyIn))
        return PySequence_PythonToCpp__QSet_QString_;
    return {};
}

// C++ to Python conversion for container type 'QSet<Akonadi::Monitor::Type>'.
static PyObject *_QSet_Akonadi_Monitor_Type__CppToPython_PySet(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QSet<Akonadi::Monitor::Type> *>(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(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Monitor_Type_IDX]))), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pyset - END

}
static void PySequence_PythonToCpp__QSet_Akonadi_Monitor_Type_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QSet<Akonadi::Monitor::Type> *>(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;
        }
        ::Akonadi::Monitor::Type cppItem = static_cast< ::Akonadi::Monitor::Type>(0);
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Enum::getConverter(reinterpret_cast<SbkEnumType *>(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Monitor_Type_IDX]))), pyItem, &(cppItem));
        (cppOutRef).insert(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsetcontainer - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QSet_Akonadi_Monitor_Type__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleIterableTypes(Shiboken::Enum::getConverter(reinterpret_cast<SbkEnumType *>(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_Monitor_Type_IDX]))), pyIn))
        return PySequence_PythonToCpp__QSet_Akonadi_Monitor_Type_;
    return {};
}

// C++ to Python conversion for container type 'QList<Akonadi::SearchTerm>'.
static PyObject *_QList_Akonadi_SearchTerm__CppToPython_PyList(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Akonadi::SearchTerm> *>(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<::Akonadi::SearchTerm>::Type cppItem = *it;
        PyList_SetItem(pyOut, idx, Shiboken::Conversions::copyToPython(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_SearchTerm_IDX]), &cppItem));
    }
    return pyOut;
    // TEMPLATE - shiboken_conversion_cppsequence_to_pylist - END

}
static void PySequence_PythonToCpp__QList_Akonadi_SearchTerm_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Akonadi::SearchTerm> *>(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;
        }
        ::Akonadi::SearchTerm cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_SearchTerm_IDX]), pyItem, &(cppItem));
        (cppOutRef).push_back(cppItem);
    }
    // TEMPLATE - shiboken_conversion_pyiterable_to_cppsequentialcontainer_reserve - END

}
static PythonToCppFunc is_PySequence_PythonToCpp__QList_Akonadi_SearchTerm__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Module::get(SbkAkonadiCoreTypeStructs[SBK_Akonadi_SearchTerm_IDX]), pyIn))
        return PySequence_PythonToCpp__QList_Akonadi_SearchTerm_;
    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 {};
}


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

static void initInheritance()
{
    [[maybe_unused]] auto &bm = Shiboken::BindingManager::instance();
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QSortFilterProxyModel_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_TrashFilterProxyModel_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QAbstractItemModel_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_TagModel_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QObject_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_TagCache_IDX]);
    bm.addClassInheritance(&SbkKCoreAddonsTypeStructs[SBK_KCompositeJob_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_SpecialCollectionsDiscoveryJob_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QObject_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_SpecialCollections_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QObject_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_Session_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QObject_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_ServerManager_IDX]);
    bm.addClassInheritance(&SbkKCoreAddonsTypeStructs[SBK_KJob_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_ResourceSynchronizationJob_IDX]);
    bm.addClassInheritance(&SbkKCoreAddonsTypeStructs[SBK_KJob_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_RecursiveItemFetchJob_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QSortFilterProxyModel_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_RecursiveCollectionFilterProxyModel_IDX]);
    bm.addClassInheritance(&SbkKCoreAddonsTypeStructs[SBK_KJob_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_PartFetcher_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QObject_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_Monitor_IDX]);
    bm.addClassInheritance(&SbkKCoreAddonsTypeStructs[SBK_KCompositeJob_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_TrashRestoreJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_TrashJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_TransactionSequence_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_TransactionSequence_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_SpecialCollectionsRequestJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_TransactionJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_TagModifyJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_TagFetchJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_TagDeleteJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_TagCreateJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_SearchCreateJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_ItemSync_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_ItemSearchJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_ItemMoveJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_ItemModifyJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_ItemFetchJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_ItemDeleteJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_ItemCreateJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_ItemCopyJob_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QAbstractItemModel_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_EntityTreeModel_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QSortFilterProxyModel_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_EntityRightsFilterModel_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QSortFilterProxyModel_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_EntityOrderProxyModel_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QSortFilterProxyModel_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_EntityMimeTypeFilterModel_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QObject_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_Control_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionStatisticsJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionPathResolver_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionMoveJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionModifyJob_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QSortFilterProxyModel_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionFilterProxyModel_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionFilterProxyModel_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_ColorProxyModel_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionFetchJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionDeleteJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionCreateJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Job_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionCopyJob_IDX]);
    bm.addClassInheritance(&SbkKCoreAddonsTypeStructs[SBK_KJob_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionAttributesSynchronizationJob_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Monitor_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_ChangeRecorder_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_TagAttribute_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_SpecialCollectionAttribute_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_PersistentSearchAttribute_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_IndexPolicyAttribute_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_FavoriteCollectionAttribute_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_EntityHiddenAttribute_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_EntityDisplayAttribute_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_EntityDeletedAttribute_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_EntityAnnotationsAttribute_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionQuotaAttribute_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionIdentificationAttribute_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionColorAttribute_IDX]);
    bm.addClassInheritance(&SbkAkonadiCoreTypeStructs[SBK_Akonadi_Attribute_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_CollectionAnnotationsAttribute_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QAbstractItemModel_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_AgentTypeModel_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QObject_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_AgentManager_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QAbstractItemModel_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_AgentInstanceModel_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QSortFilterProxyModel_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_AgentInstanceFilterProxyModel_IDX]);
    bm.addClassInheritance(&SbkKCoreAddonsTypeStructs[SBK_KJob_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_AgentInstanceCreateJob_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QSortFilterProxyModel_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_AgentFilterProxyModel_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QObject_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_AgentConfigurationBase_IDX]);
    bm.addClassInheritance(&SbkPySide6_QtCoreTypeStructs[SBK_QObject_IDX],
                           &SbkAkonadiCoreTypeStructs[SBK_Akonadi_AccountActivitiesAbstract_IDX]);
}

static void initTypes_AkonadiCore(PyObject *module)
{
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_AkonadiCoreAkonadi);
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_AkonadiCoreAkonadi_TrashSettings, "Akonadi.TrashSettings");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_TrashFilterProxyModel, "Akonadi.TrashFilterProxyModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_TagModel, "Akonadi.TagModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_TagFetchScope, "Akonadi.TagFetchScope");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_TagCache, "Akonadi.TagCache");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_Tag, "Akonadi.Tag");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_StatisticsProxyModel, "Akonadi.StatisticsProxyModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_SpecialCollectionsDiscoveryJob, "Akonadi.SpecialCollectionsDiscoveryJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_SpecialCollections, "Akonadi.SpecialCollections");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_Session, "Akonadi.Session");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ServerManager, "Akonadi.ServerManager");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_SelectionProxyModel, "Akonadi.SelectionProxyModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_SearchTerm, "Akonadi.SearchTerm");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_SearchQuery, "Akonadi.SearchQuery");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ResourceSynchronizationJob, "Akonadi.ResourceSynchronizationJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_RecursiveItemFetchJob, "Akonadi.RecursiveItemFetchJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_RecursiveCollectionFilterProxyModel, "Akonadi.RecursiveCollectionFilterProxyModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_PartFetcher, "Akonadi.PartFetcher");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_NotificationSubscriber, "Akonadi.NotificationSubscriber");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_Monitor, "Akonadi.Monitor");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_MimeTypeChecker, "Akonadi.MimeTypeChecker");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_Job, "Akonadi.Job");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_TrashRestoreJob, "Akonadi.TrashRestoreJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_TrashJob, "Akonadi.TrashJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_TransactionSequence, "Akonadi.TransactionSequence");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_SpecialCollectionsRequestJob, "Akonadi.SpecialCollectionsRequestJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_TransactionJob, "Akonadi.TransactionJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_TagModifyJob, "Akonadi.TagModifyJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_TagFetchJob, "Akonadi.TagFetchJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_TagDeleteJob, "Akonadi.TagDeleteJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_TagCreateJob, "Akonadi.TagCreateJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_SearchCreateJob, "Akonadi.SearchCreateJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ItemSync, "Akonadi.ItemSync");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ItemSearchJob, "Akonadi.ItemSearchJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ItemMoveJob, "Akonadi.ItemMoveJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ItemMonitor, "Akonadi.ItemMonitor");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ItemModifyJob, "Akonadi.ItemModifyJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ItemFetchScope, "Akonadi.ItemFetchScope");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ItemFetchJob, "Akonadi.ItemFetchJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ItemDeleteJob, "Akonadi.ItemDeleteJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ItemCreateJob, "Akonadi.ItemCreateJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ItemCopyJob, "Akonadi.ItemCopyJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_Item, "Akonadi.Item");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_GidExtractorInterface, "Akonadi.GidExtractorInterface");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_FavoriteCollectionsModel, "Akonadi.FavoriteCollectionsModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_Exception, "Akonadi.Exception");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_EntityTreeModel, "Akonadi.EntityTreeModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_EntityRightsFilterModel, "Akonadi.EntityRightsFilterModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_EntityOrderProxyModel, "Akonadi.EntityOrderProxyModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_EntityMimeTypeFilterModel, "Akonadi.EntityMimeTypeFilterModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_DifferencesAlgorithmInterface, "Akonadi.DifferencesAlgorithmInterface");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_Control, "Akonadi.Control");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_AkonadiCoreAkonadi_CollectionUtils, "Akonadi.CollectionUtils");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionStatisticsJob, "Akonadi.CollectionStatisticsJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionStatistics, "Akonadi.CollectionStatistics");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionPathResolver, "Akonadi.CollectionPathResolver");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionMoveJob, "Akonadi.CollectionMoveJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionModifyJob, "Akonadi.CollectionModifyJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionFilterProxyModel, "Akonadi.CollectionFilterProxyModel");
    Shiboken::Module::AddTypeCreationFunction(module, "ColorProxyModel", init_ColorProxyModel);
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionFetchScope, "Akonadi.CollectionFetchScope");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionFetchJob, "Akonadi.CollectionFetchJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionDeleteJob, "Akonadi.CollectionDeleteJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionCreateJob, "Akonadi.CollectionCreateJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionCopyJob, "Akonadi.CollectionCopyJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionAttributesSynchronizationJob, "Akonadi.CollectionAttributesSynchronizationJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_Collection, "Akonadi.Collection");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ChangeRecorder, "Akonadi.ChangeRecorder");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_ChangeNotification, "Akonadi.ChangeNotification");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CachePolicy, "Akonadi.CachePolicy");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_AttributeFactory, "Akonadi.AttributeFactory");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_Attribute, "Akonadi.Attribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_TagAttribute, "Akonadi.TagAttribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_SpecialCollectionAttribute, "Akonadi.SpecialCollectionAttribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_PersistentSearchAttribute, "Akonadi.PersistentSearchAttribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_IndexPolicyAttribute, "Akonadi.IndexPolicyAttribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_FavoriteCollectionAttribute, "Akonadi.FavoriteCollectionAttribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_EntityHiddenAttribute, "Akonadi.EntityHiddenAttribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_EntityDisplayAttribute, "Akonadi.EntityDisplayAttribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_EntityDeletedAttribute, "Akonadi.EntityDeletedAttribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_EntityAnnotationsAttribute, "Akonadi.EntityAnnotationsAttribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionQuotaAttribute, "Akonadi.CollectionQuotaAttribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionIdentificationAttribute, "Akonadi.CollectionIdentificationAttribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionColorAttribute, "Akonadi.CollectionColorAttribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_CollectionAnnotationsAttribute, "Akonadi.CollectionAnnotationsAttribute");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_AgentTypeModel, "Akonadi.AgentTypeModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_AgentType, "Akonadi.AgentType");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_AgentManager, "Akonadi.AgentManager");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_AgentInstanceModel, "Akonadi.AgentInstanceModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_AgentInstanceFilterProxyModel, "Akonadi.AgentInstanceFilterProxyModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_AgentInstanceCreateJob, "Akonadi.AgentInstanceCreateJob");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_AgentInstance, "Akonadi.AgentInstance");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_AgentFilterProxyModel, "Akonadi.AgentFilterProxyModel");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_AgentConfigurationBase, "Akonadi.AgentConfigurationBase");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_AccountActivitiesAbstract, "Akonadi.AccountActivitiesAbstract");
    Shiboken::Module::AddTypeCreationFunction(module, "Akonadi", init_Akonadi_AbstractDifferencesReporter, "Akonadi.AbstractDifferencesReporter");
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Shiboken::Conversions::registerConverterAlias(Shiboken::Conversions::PrimitiveTypeConverter<size_t>(), "Py_uhash_t");

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

    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<int>(), "descrsetfunc");

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

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

    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<int>(), "gcvisitobjects_t");

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

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

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

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

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

    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<int>(), "inquiry");

    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>(), "lenfunc");

    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<int>(), "objobjargproc");

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

    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<long>(), "printfunc");

    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<int>(), "sdigit");

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

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

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

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

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

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

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

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

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

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

    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");

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

}

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

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

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

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

    // Register converter for type 'QMap<QByteArray,QByteArray>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QMap_QByteArray_QByteArray_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QMap_QByteArray_QByteArray__CppToPython_PyDict);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QMap_QByteArray_QByteArray_IDX], "QMap<QByteArray,QByteArray>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QMap_QByteArray_QByteArray_IDX],
        PyDict_PythonToCpp__QMap_QByteArray_QByteArray_,
        is_PyDict_PythonToCpp__QMap_QByteArray_QByteArray__Convertible);

    // Register converter for type 'QList<qint64>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_qint64_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_qint64__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_qint64_IDX], "QList<qint64>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_qint64_IDX],
        PySequence_PythonToCpp__QList_qint64_,
        is_PySequence_PythonToCpp__QList_qint64__Convertible);

    // Register converter for type 'QList<Akonadi::Collection>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Collection_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Akonadi_Collection__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Collection_IDX], "QList<Akonadi::Collection>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Collection_IDX],
        PySequence_PythonToCpp__QList_Akonadi_Collection_,
        is_PySequence_PythonToCpp__QList_Akonadi_Collection__Convertible);
    // Register converters for type aliases of QList<Akonadi::Collection>'.
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Collection_IDX], "Akonadi::Collection::List");

    // Register converter for type 'QList<Akonadi::Attribute*>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_AttributePTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Akonadi_AttributePTR__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_AttributePTR_IDX], "QList<Akonadi::Attribute*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_AttributePTR_IDX],
        PySequence_PythonToCpp__QList_Akonadi_AttributePTR_,
        is_PySequence_PythonToCpp__QList_Akonadi_AttributePTR__Convertible);
    // Register converters for type aliases of QList<Akonadi::Attribute*>'.
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_AttributePTR_IDX], "Akonadi::Attribute::List");

    // Register converter for type 'QSet<QByteArray>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_QByteArray_IDX] = Shiboken::Conversions::createConverter(&PySet_Type, _QSet_QByteArray__CppToPython_PySet);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_QByteArray_IDX], "QSet<QByteArray>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_QByteArray_IDX],
        PySequence_PythonToCpp__QSet_QByteArray_,
        is_PySequence_PythonToCpp__QSet_QByteArray__Convertible);
    // Register converters for type aliases of QSet<QByteArray>'.
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_QByteArray_IDX], "Akonadi::Item::Flags");

    // Register converter for type 'QList<long long>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_longlong_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_longlong__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_longlong_IDX], "QList<long long>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_longlong_IDX],
        PySequence_PythonToCpp__QList_longlong_,
        is_PySequence_PythonToCpp__QList_longlong__Convertible);

    // Register converter for type 'QList<Akonadi::Item>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Item_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Akonadi_Item__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Item_IDX], "QList<Akonadi::Item>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Item_IDX],
        PySequence_PythonToCpp__QList_Akonadi_Item_,
        is_PySequence_PythonToCpp__QList_Akonadi_Item__Convertible);
    // Register converters for type aliases of QList<Akonadi::Item>'.
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Item_IDX], "Akonadi::Item::List");

    // Register converter for type 'QMap<QString,QVariant>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QMap_QString_QVariant_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QMap_QString_QVariant__CppToPython_PyDict);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QMap_QString_QVariant_IDX], "QMap<QString,QVariant>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_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(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QMap_QString_QVariant_IDX], "QVariantMap");
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QMap_QString_QVariant_IDX], "QVariantMap");

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

    // Register converter for type 'QList<QByteArray>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_QByteArray_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QByteArray__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_QByteArray_IDX], "QList<QByteArray>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_QByteArray_IDX],
        PySequence_PythonToCpp__QList_QByteArray_,
        is_PySequence_PythonToCpp__QList_QByteArray__Convertible);
    // Register converters for type aliases of QList<QByteArray>'.
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_QByteArray_IDX], "QByteArrayList");

    // Register converter for type 'QList<Akonadi::Tag>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Tag_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Akonadi_Tag__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Tag_IDX], "QList<Akonadi::Tag>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Tag_IDX],
        PySequence_PythonToCpp__QList_Akonadi_Tag_,
        is_PySequence_PythonToCpp__QList_Akonadi_Tag__Convertible);
    // Register converters for type aliases of QList<Akonadi::Tag>'.
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Tag_IDX], "Akonadi::Tag::List");

    // Register converter for type 'QList<QUrl>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_QUrl_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QUrl__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_QUrl_IDX], "QList<QUrl>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_QUrl_IDX],
        PySequence_PythonToCpp__QList_QUrl_,
        is_PySequence_PythonToCpp__QList_QUrl__Convertible);

    // Register converter for type 'QList<Akonadi::AgentInstance>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_AgentInstance_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Akonadi_AgentInstance__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_AgentInstance_IDX], "QList<Akonadi::AgentInstance>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_AgentInstance_IDX],
        PySequence_PythonToCpp__QList_Akonadi_AgentInstance_,
        is_PySequence_PythonToCpp__QList_Akonadi_AgentInstance__Convertible);
    // Register converters for type aliases of QList<Akonadi::AgentInstance>'.
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_AgentInstance_IDX], "Akonadi::AgentInstance::List");

    // Register converter for type 'QList<Akonadi::AgentType>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_AgentType_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Akonadi_AgentType__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_AgentType_IDX], "QList<Akonadi::AgentType>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_AgentType_IDX],
        PySequence_PythonToCpp__QList_Akonadi_AgentType_,
        is_PySequence_PythonToCpp__QList_Akonadi_AgentType__Convertible);
    // Register converters for type aliases of QList<Akonadi::AgentType>'.
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_AgentType_IDX], "Akonadi::AgentType::List");

    // Register converter for type 'QSet<Akonadi::Tag>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_Akonadi_Tag_IDX] = Shiboken::Conversions::createConverter(&PySet_Type, _QSet_Akonadi_Tag__CppToPython_PySet);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_Akonadi_Tag_IDX], "QSet<Akonadi::Tag>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_Akonadi_Tag_IDX],
        PySequence_PythonToCpp__QSet_Akonadi_Tag_,
        is_PySequence_PythonToCpp__QSet_Akonadi_Tag__Convertible);

    // Register converter for type 'QList<Akonadi::Monitor::Type>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Monitor_Type_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Akonadi_Monitor_Type__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Monitor_Type_IDX], "QList<Akonadi::Monitor::Type>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_Monitor_Type_IDX],
        PySequence_PythonToCpp__QList_Akonadi_Monitor_Type_,
        is_PySequence_PythonToCpp__QList_Akonadi_Monitor_Type__Convertible);

    // Register converter for type 'QSet<qint64>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_qint64_IDX] = Shiboken::Conversions::createConverter(&PySet_Type, _QSet_qint64__CppToPython_PySet);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_qint64_IDX], "QSet<qint64>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_qint64_IDX],
        PySequence_PythonToCpp__QSet_qint64_,
        is_PySequence_PythonToCpp__QSet_qint64__Convertible);

    // Register converter for type 'QSet<QString>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_QString_IDX] = Shiboken::Conversions::createConverter(&PySet_Type, _QSet_QString__CppToPython_PySet);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_QString_IDX], "QSet<QString>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_QString_IDX],
        PySequence_PythonToCpp__QSet_QString_,
        is_PySequence_PythonToCpp__QSet_QString__Convertible);

    // Register converter for type 'QSet<Akonadi::Monitor::Type>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_Akonadi_Monitor_Type_IDX] = Shiboken::Conversions::createConverter(&PySet_Type, _QSet_Akonadi_Monitor_Type__CppToPython_PySet);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_Akonadi_Monitor_Type_IDX], "QSet<Akonadi::Monitor::Type>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QSet_Akonadi_Monitor_Type_IDX],
        PySequence_PythonToCpp__QSet_Akonadi_Monitor_Type_,
        is_PySequence_PythonToCpp__QSet_Akonadi_Monitor_Type__Convertible);

    // Register converter for type 'QList<Akonadi::SearchTerm>'.
    SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_SearchTerm_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Akonadi_SearchTerm__CppToPython_PyList);
    Shiboken::Conversions::registerConverterName(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_SearchTerm_IDX], "QList<Akonadi::SearchTerm>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkAkonadiCoreTypeConverters[SBK_AkonadiCore_QList_Akonadi_SearchTerm_IDX],
        PySequence_PythonToCpp__QList_Akonadi_SearchTerm_,
        is_PySequence_PythonToCpp__QList_Akonadi_SearchTerm__Convertible);

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

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

}

static void registerOpaqueContainers_AkonadiCore(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, "AkonadiCore.Akonadi"},
    {nullptr, "AkonadiCore.Akonadi.AbstractDifferencesReporter"},
    {nullptr, "AkonadiCore.Akonadi.AbstractDifferencesReporter.Mode"},
    {nullptr, "AkonadiCore.Akonadi.AccountActivitiesAbstract"},
    {nullptr, "AkonadiCore.Akonadi.AgentConfigurationBase"},
    {nullptr, "AkonadiCore.Akonadi.AgentFilterProxyModel"},
    {nullptr, "AkonadiCore.Akonadi.AgentInstance"},
    {nullptr, "AkonadiCore.Akonadi.AgentInstance.Status"},
    {nullptr, "AkonadiCore.Akonadi.AgentInstanceCreateJob"},
    {nullptr, "AkonadiCore.Akonadi.AgentInstanceFilterProxyModel"},
    {nullptr, "AkonadiCore.Akonadi.AgentInstanceModel"},
    {nullptr, "AkonadiCore.Akonadi.AgentInstanceModel.Roles"},
    {nullptr, "AkonadiCore.Akonadi.AgentManager"},
    {nullptr, "AkonadiCore.Akonadi.AgentType"},
    {nullptr, "AkonadiCore.Akonadi.AgentTypeModel"},
    {nullptr, "AkonadiCore.Akonadi.AgentTypeModel.Roles"},
    {nullptr, "AkonadiCore.Akonadi.Attribute"},
    {nullptr, "AkonadiCore.Akonadi.AttributeFactory"},
    {nullptr, "AkonadiCore.Akonadi.CachePolicy"},
    {nullptr, "AkonadiCore.Akonadi.ChangeNotification"},
    {nullptr, "AkonadiCore.Akonadi.ChangeNotification.Type"},
    {nullptr, "AkonadiCore.Akonadi.ChangeRecorder"},
    {nullptr, "AkonadiCore.Akonadi.Collection"},
    {nullptr, "AkonadiCore.Akonadi.Collection.CreateOption"},
    {nullptr, "AkonadiCore.Akonadi.Collection.ListPreference"},
    {nullptr, "AkonadiCore.Akonadi.Collection.ListPurpose"},
    {nullptr, "AkonadiCore.Akonadi.Collection.Right"},
    {nullptr, "AkonadiCore.Akonadi.Collection.UrlType"},
    {nullptr, "AkonadiCore.Akonadi.CollectionAnnotationsAttribute"},
    {nullptr, "AkonadiCore.Akonadi.CollectionAttributesSynchronizationJob"},
    {nullptr, "AkonadiCore.Akonadi.CollectionColorAttribute"},
    {nullptr, "AkonadiCore.Akonadi.CollectionCopyJob"},
    {nullptr, "AkonadiCore.Akonadi.CollectionCreateJob"},
    {nullptr, "AkonadiCore.Akonadi.CollectionDeleteJob"},
    {nullptr, "AkonadiCore.Akonadi.CollectionFetchJob"},
    {nullptr, "AkonadiCore.Akonadi.CollectionFetchJob.Type"},
    {nullptr, "AkonadiCore.Akonadi.CollectionFetchScope"},
    {nullptr, "AkonadiCore.Akonadi.CollectionFetchScope.AncestorRetrieval"},
    {nullptr, "AkonadiCore.Akonadi.CollectionFetchScope.ListFilter"},
    {nullptr, "AkonadiCore.Akonadi.CollectionFilterProxyModel"},
    {nullptr, "AkonadiCore.Akonadi.CollectionIdentificationAttribute"},
    {nullptr, "AkonadiCore.Akonadi.CollectionModifyJob"},
    {nullptr, "AkonadiCore.Akonadi.CollectionMoveJob"},
    {nullptr, "AkonadiCore.Akonadi.CollectionPathResolver"},
    {nullptr, "AkonadiCore.Akonadi.CollectionQuotaAttribute"},
    {nullptr, "AkonadiCore.Akonadi.CollectionStatistics"},
    {nullptr, "AkonadiCore.Akonadi.CollectionStatisticsJob"},
    {nullptr, "AkonadiCore.Akonadi.CollectionUtils"},
    {nullptr, "AkonadiCore.Akonadi.Control"},
    {nullptr, "AkonadiCore.Akonadi.DifferencesAlgorithmInterface"},
    {nullptr, "AkonadiCore.Akonadi.EntityAnnotationsAttribute"},
    {nullptr, "AkonadiCore.Akonadi.EntityDeletedAttribute"},
    {nullptr, "AkonadiCore.Akonadi.EntityDisplayAttribute"},
    {nullptr, "AkonadiCore.Akonadi.EntityHiddenAttribute"},
    {nullptr, "AkonadiCore.Akonadi.EntityMimeTypeFilterModel"},
    {nullptr, "AkonadiCore.Akonadi.EntityOrderProxyModel"},
    {nullptr, "AkonadiCore.Akonadi.EntityRightsFilterModel"},
    {nullptr, "AkonadiCore.Akonadi.EntityTreeModel"},
    {nullptr, "AkonadiCore.Akonadi.EntityTreeModel.CollectionFetchStrategy"},
    {nullptr, "AkonadiCore.Akonadi.EntityTreeModel.FetchState"},
    {nullptr, "AkonadiCore.Akonadi.EntityTreeModel.HeaderGroup"},
    {nullptr, "AkonadiCore.Akonadi.EntityTreeModel.ItemPopulationStrategy"},
    {nullptr, "AkonadiCore.Akonadi.EntityTreeModel.Roles"},
    {nullptr, "AkonadiCore.Akonadi.Exception"},
    {nullptr, "AkonadiCore.Akonadi.FavoriteCollectionAttribute"},
    {nullptr, "AkonadiCore.Akonadi.FavoriteCollectionsModel"},
    {nullptr, "AkonadiCore.Akonadi.GidExtractorInterface"},
    {nullptr, "AkonadiCore.Akonadi.IndexPolicyAttribute"},
    {nullptr, "AkonadiCore.Akonadi.Item"},
    {nullptr, "AkonadiCore.Akonadi.Item.CreateOption"},
    {nullptr, "AkonadiCore.Akonadi.Item.UrlType"},
    {nullptr, "AkonadiCore.Akonadi.ItemCopyJob"},
    {nullptr, "AkonadiCore.Akonadi.ItemCreateJob"},
    {nullptr, "AkonadiCore.Akonadi.ItemCreateJob.MergeOption"},
    {nullptr, "AkonadiCore.Akonadi.ItemDeleteJob"},
    {nullptr, "AkonadiCore.Akonadi.ItemFetchJob"},
    {nullptr, "AkonadiCore.Akonadi.ItemFetchJob.DeliveryOption"},
    {nullptr, "AkonadiCore.Akonadi.ItemFetchScope"},
    {nullptr, "AkonadiCore.Akonadi.ItemFetchScope.AncestorRetrieval"},
    {nullptr, "AkonadiCore.Akonadi.ItemModifyJob"},
    {nullptr, "AkonadiCore.Akonadi.ItemMonitor"},
    {nullptr, "AkonadiCore.Akonadi.ItemMoveJob"},
    {nullptr, "AkonadiCore.Akonadi.ItemSearchJob"},
    {nullptr, "AkonadiCore.Akonadi.ItemSync"},
    {nullptr, "AkonadiCore.Akonadi.ItemSync.MergeMode"},
    {nullptr, "AkonadiCore.Akonadi.ItemSync.TransactionMode"},
    {nullptr, "AkonadiCore.Akonadi.Job"},
    {nullptr, "AkonadiCore.Akonadi.Job.Error"},
    {nullptr, "AkonadiCore.Akonadi.MimeTypeChecker"},
    {nullptr, "AkonadiCore.Akonadi.Monitor"},
    {nullptr, "AkonadiCore.Akonadi.Monitor.Type"},
    {nullptr, "AkonadiCore.Akonadi.NotificationSubscriber"},
    {nullptr, "AkonadiCore.Akonadi.PartFetcher"},
    {nullptr, "AkonadiCore.Akonadi.PersistentSearchAttribute"},
    {nullptr, "AkonadiCore.Akonadi.RecursiveCollectionFilterProxyModel"},
    {nullptr, "AkonadiCore.Akonadi.RecursiveItemFetchJob"},
    {nullptr, "AkonadiCore.Akonadi.ResourceSynchronizationJob"},
    {nullptr, "AkonadiCore.Akonadi.SearchCreateJob"},
    {nullptr, "AkonadiCore.Akonadi.SearchQuery"},
    {nullptr, "AkonadiCore.Akonadi.SearchTerm"},
    {nullptr, "AkonadiCore.Akonadi.SearchTerm.Condition"},
    {nullptr, "AkonadiCore.Akonadi.SearchTerm.Relation"},
    {nullptr, "AkonadiCore.Akonadi.SelectionProxyModel"},
    {nullptr, "AkonadiCore.Akonadi.ServerManager"},
    {nullptr, "AkonadiCore.Akonadi.ServerManager.OpenMode"},
    {nullptr, "AkonadiCore.Akonadi.ServerManager.ServiceAgentType"},
    {nullptr, "AkonadiCore.Akonadi.ServerManager.ServiceType"},
    {nullptr, "AkonadiCore.Akonadi.ServerManager.State"},
    {nullptr, "AkonadiCore.Akonadi.Session"},
    {nullptr, "AkonadiCore.Akonadi.SpecialCollectionAttribute"},
    {nullptr, "AkonadiCore.Akonadi.SpecialCollections"},
    {nullptr, "AkonadiCore.Akonadi.SpecialCollectionsDiscoveryJob"},
    {nullptr, "AkonadiCore.Akonadi.SpecialCollectionsRequestJob"},
    {nullptr, "AkonadiCore.Akonadi.StatisticsProxyModel"},
    {nullptr, "AkonadiCore.Akonadi.Tag"},
    {nullptr, "AkonadiCore.Akonadi.Tag.CreateOption"},
    {nullptr, "AkonadiCore.Akonadi.TagAttribute"},
    {nullptr, "AkonadiCore.Akonadi.TagCache"},
    {nullptr, "AkonadiCore.Akonadi.TagCreateJob"},
    {nullptr, "AkonadiCore.Akonadi.TagDeleteJob"},
    {nullptr, "AkonadiCore.Akonadi.TagFetchJob"},
    {nullptr, "AkonadiCore.Akonadi.TagFetchScope"},
    {nullptr, "AkonadiCore.Akonadi.TagModel"},
    {nullptr, "AkonadiCore.Akonadi.TagModel.Roles"},
    {nullptr, "AkonadiCore.Akonadi.TagModifyJob"},
    {nullptr, "AkonadiCore.Akonadi.TransactionJob"},
    {nullptr, "AkonadiCore.Akonadi.TransactionSequence"},
    {nullptr, "AkonadiCore.Akonadi.TrashFilterProxyModel"},
    {nullptr, "AkonadiCore.Akonadi.TrashJob"},
    {nullptr, "AkonadiCore.Akonadi.TrashRestoreJob"},
    {nullptr, "AkonadiCore.Akonadi.TrashSettings"},
    {nullptr, "AkonadiCore.ColorProxyModel"},
    {nullptr, "AkonadiCore.ColorProxyModel.Roles"},
    {nullptr, "AkonadiCore.Akonadi.Collection.Rights"},
    {nullptr, "AkonadiCore.Akonadi.ItemCreateJob.MergeOptions"},
    {nullptr, "AkonadiCore.Akonadi.ItemFetchJob.DeliveryOptions"},
    {nullptr, nullptr}
};

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

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

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

    registerOpaqueContainers_AkonadiCore(module);

    Shiboken::Module::registerTypes(module, SbkAkonadiCoreTypeStructs);
    Shiboken::Module::registerTypeConverters(module, SbkAkonadiCoreTypeConverters);

    // Static field initialization
    init_Akonadi_TagStaticFields(module);
    init_Akonadi_ItemStaticFields(module);

    initInheritance();

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

#if PYSIDE6_COMOPT_COMPRESS == 0
    FinishSignatureInitialization(module, AkonadiCore_SignatureStrings);
#else
    if (FinishSignatureInitBytes(module, AkonadiCore_SignatureBytes, AkonadiCore_SignatureByteSize) < 0)
        return -1;
#endif

    return 0;
}
} // extern "C"

static PyModuleDef_Slot AkonadiCoreModuleSlots[] = {
    {Py_mod_exec, reinterpret_cast<void *>(exec_AkonadiCore)},
#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 AkonadiCoreModuleDef = {
    /* m_base     */ PyModuleDef_HEAD_INIT,
    /* m_name     */ "AkonadiCore",
    /* m_doc      */ nullptr,
    /* m_size     */ 0,
    /* m_methods  */ AkonadiCoreMethods,
    /* m_slots    */ AkonadiCoreModuleSlots,
    /* m_traverse */ nullptr,
    /* m_clear    */ nullptr,
    /* m_free     */ nullptr
};

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

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

    SbkAkonadiCoreTypeConverters = 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);
    }

    {
        Shiboken::AutoDecRef requiredModule(Shiboken::Module::import("KCoreAddons"));
        if (requiredModule.isNull())
            return nullptr;
        SbkKCoreAddonsTypeStructs = Shiboken::Module::getTypes(requiredModule);
        SbkKCoreAddonsTypeConverters = Shiboken::Module::getTypeConverters(requiredModule);
    }

    initConverters_AkonadiCore();
    initContainerConverters_AkonadiCore();

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

