/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of Qt for Python.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 3 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL3 included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 3 requirements
** will be met: https://www.gnu.org/licenses/lgpl-3.0.html.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 2.0 or (at your option) the GNU General
** Public license version 3 or any later version approved by the KDE Free
** Qt Foundation. The licenses are as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL2 and LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-2.0.html and
** https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

#include <sbkpython.h>
#include <shiboken.h>
#include <algorithm>
#include <signature.h>
#include <sbkcontainer.h>
#include <sbkstaticstrings.h>
#ifndef QT_NO_VERSION_TAGGING
#  define QT_NO_VERSION_TAGGING
#endif
#include <QDebug>
#include <pyside.h>
#include <pysideqenum.h>
#include <feature_select.h>
#include "pyside6_qt3drender_python.h"



// Current module's type array.
PyTypeObject **SbkPySide6_Qt3DRenderTypes = nullptr;
// Current module's PyObject pointer.
PyObject *SbkPySide6_Qt3DRenderModuleObject = nullptr;
// Current module's converter array.
SbkConverter **SbkPySide6_Qt3DRenderTypeConverters = nullptr;
void cleanTypesAttributes() {
    for (int i = 0, imax = SBK_Qt3DRender_IDX_COUNT; i < imax; i++) {
        PyObject *pyType = reinterpret_cast<PyObject *>(SbkPySide6_Qt3DRenderTypes[i]);
        Shiboken::AutoDecRef attrName(Py_BuildValue("s", "staticMetaObject"));
        if (pyType && PyObject_HasAttr(pyType, attrName))
            PyObject_SetAttr(pyType, attrName, Py_None);
    }
}
// Global functions ------------------------------------------------------------

static PyMethodDef Qt3DRender_methods[] = {
    {0} // Sentinel
};

// Classes initialization functions ------------------------------------------------------------
void init_Qt3DRenderQt3DRender(PyObject *module);
void init_Qt3DRender_QTextureWrapMode(PyObject *enclosingClass);
void init_Qt3DRender_QTextureImageData(PyObject *enclosingClass);
void init_Qt3DRender_QTextureDataUpdate(PyObject *enclosingClass);
void init_Qt3DRender_QTextureData(PyObject *enclosingClass);
void init_Qt3DRender_QStencilTestArguments(PyObject *enclosingClass);
void init_Qt3DRender_QStencilOperationArguments(PyObject *enclosingClass);
void init_Qt3DRender_QRenderCaptureReply(PyObject *enclosingClass);
void init_Qt3DRender_QRenderCapabilities(PyObject *enclosingClass);
void init_Qt3DRender_QRayCasterHit(PyObject *enclosingClass);
void init_Qt3DRender_QPickEvent(PyObject *enclosingClass);
void init_Qt3DRender_QPickTriangleEvent(PyObject *enclosingClass);
void init_Qt3DRender_QPickPointEvent(PyObject *enclosingClass);
void init_Qt3DRender_QPickLineEvent(PyObject *enclosingClass);
void init_Qt3DRender_QLevelOfDetailBoundingSphere(PyObject *enclosingClass);
void init_Qt3DRender_QGraphicsApiFilter(PyObject *enclosingClass);
void init_Qt3DRender_PropertyReaderInterface(PyObject *enclosingClass);
void init_Qt3DRender_QTechnique(PyObject *enclosingClass);
void init_Qt3DRender_QShaderProgramBuilder(PyObject *enclosingClass);
void init_Qt3DRender_QShaderProgram(PyObject *enclosingClass);
void init_Qt3DRender_QShaderImage(PyObject *enclosingClass);
void init_Qt3DRender_QRenderTargetOutput(PyObject *enclosingClass);
void init_Qt3DRender_QRenderState(PyObject *enclosingClass);
void init_Qt3DRender_QStencilTest(PyObject *enclosingClass);
void init_Qt3DRender_QStencilOperation(PyObject *enclosingClass);
void init_Qt3DRender_QStencilMask(PyObject *enclosingClass);
void init_Qt3DRender_QSeamlessCubemap(PyObject *enclosingClass);
void init_Qt3DRender_QScissorTest(PyObject *enclosingClass);
void init_Qt3DRender_QRasterMode(PyObject *enclosingClass);
void init_Qt3DRender_QPolygonOffset(PyObject *enclosingClass);
void init_Qt3DRender_QPointSize(PyObject *enclosingClass);
void init_Qt3DRender_QNoDepthMask(PyObject *enclosingClass);
void init_Qt3DRender_QMultiSampleAntiAliasing(PyObject *enclosingClass);
void init_Qt3DRender_QLineWidth(PyObject *enclosingClass);
void init_Qt3DRender_QFrontFace(PyObject *enclosingClass);
void init_Qt3DRender_QDithering(PyObject *enclosingClass);
void init_Qt3DRender_QDepthTest(PyObject *enclosingClass);
void init_Qt3DRender_QDepthRange(PyObject *enclosingClass);
void init_Qt3DRender_QCullFace(PyObject *enclosingClass);
void init_Qt3DRender_QColorMask(PyObject *enclosingClass);
void init_Qt3DRender_QClipPlane(PyObject *enclosingClass);
void init_Qt3DRender_QBlendEquationArguments(PyObject *enclosingClass);
void init_Qt3DRender_QBlendEquation(PyObject *enclosingClass);
void init_Qt3DRender_QAlphaTest(PyObject *enclosingClass);
void init_Qt3DRender_QAlphaCoverage(PyObject *enclosingClass);
void init_Qt3DRender_QRenderPass(PyObject *enclosingClass);
void init_Qt3DRender_QPickingSettings(PyObject *enclosingClass);
void init_Qt3DRender_QParameter(PyObject *enclosingClass);
void init_Qt3DRender_QFrameGraphNode(PyObject *enclosingClass);
void init_Qt3DRender_QWaitFence(PyObject *enclosingClass);
void init_Qt3DRender_QViewport(PyObject *enclosingClass);
void init_Qt3DRender_QTechniqueFilter(PyObject *enclosingClass);
void init_Qt3DRender_QSubtreeEnabler(PyObject *enclosingClass);
void init_Qt3DRender_QSortPolicy(PyObject *enclosingClass);
void init_Qt3DRender_QSetFence(PyObject *enclosingClass);
void init_Qt3DRender_QRenderTargetSelector(PyObject *enclosingClass);
void init_Qt3DRender_QRenderSurfaceSelector(PyObject *enclosingClass);
void init_Qt3DRender_QRenderStateSet(PyObject *enclosingClass);
void init_Qt3DRender_QRenderPassFilter(PyObject *enclosingClass);
void init_Qt3DRender_QRenderCapture(PyObject *enclosingClass);
void init_Qt3DRender_QProximityFilter(PyObject *enclosingClass);
void init_Qt3DRender_QNoPicking(PyObject *enclosingClass);
void init_Qt3DRender_QNoDraw(PyObject *enclosingClass);
void init_Qt3DRender_QMemoryBarrier(PyObject *enclosingClass);
void init_Qt3DRender_QLayerFilter(PyObject *enclosingClass);
void init_Qt3DRender_QFrustumCulling(PyObject *enclosingClass);
void init_Qt3DRender_QDispatchCompute(PyObject *enclosingClass);
void init_Qt3DRender_QClearBuffers(PyObject *enclosingClass);
void init_Qt3DRender_QCameraSelector(PyObject *enclosingClass);
void init_Qt3DRender_QBufferCapture(PyObject *enclosingClass);
void init_Qt3DRender_QBlitFramebuffer(PyObject *enclosingClass);
void init_Qt3DRender_QFilterKey(PyObject *enclosingClass);
void init_Qt3DRender_QEffect(PyObject *enclosingClass);
void init_Qt3DRender_QAbstractTextureImage(PyObject *enclosingClass);
void init_Qt3DRender_QTextureImage(PyObject *enclosingClass);
void init_Qt3DRender_QPaintedTextureImage(PyObject *enclosingClass);
void init_Qt3DRender_QAbstractTexture(PyObject *enclosingClass);
void init_Qt3DRender_QTextureRectangle(PyObject *enclosingClass);
void init_Qt3DRender_QTextureLoader(PyObject *enclosingClass);
void init_Qt3DRender_QTextureCubeMapArray(PyObject *enclosingClass);
void init_Qt3DRender_QTextureCubeMap(PyObject *enclosingClass);
void init_Qt3DRender_QTextureBuffer(PyObject *enclosingClass);
void init_Qt3DRender_QTexture3D(PyObject *enclosingClass);
void init_Qt3DRender_QTexture2DMultisampleArray(PyObject *enclosingClass);
void init_Qt3DRender_QTexture2DMultisample(PyObject *enclosingClass);
void init_Qt3DRender_QTexture2DArray(PyObject *enclosingClass);
void init_Qt3DRender_QTexture2D(PyObject *enclosingClass);
void init_Qt3DRender_QTexture1DArray(PyObject *enclosingClass);
void init_Qt3DRender_QTexture1D(PyObject *enclosingClass);
void init_Qt3DRender_QSharedGLTexture(PyObject *enclosingClass);
void init_Qt3DRender_QCamera(PyObject *enclosingClass);
void init_Qt3DRender_QShaderData(PyObject *enclosingClass);
void init_Qt3DRender_QSceneLoader(PyObject *enclosingClass);
void init_Qt3DRender_QRenderTarget(PyObject *enclosingClass);
void init_Qt3DRender_QRenderSettings(PyObject *enclosingClass);
void init_Qt3DRender_QObjectPicker(PyObject *enclosingClass);
void init_Qt3DRender_QMaterial(PyObject *enclosingClass);
void init_Qt3DRender_QLevelOfDetail(PyObject *enclosingClass);
void init_Qt3DRender_QLevelOfDetailSwitch(PyObject *enclosingClass);
void init_Qt3DRender_QLayer(PyObject *enclosingClass);
void init_Qt3DRender_QEnvironmentLight(PyObject *enclosingClass);
void init_Qt3DRender_QComputeCommand(PyObject *enclosingClass);
void init_Qt3DRender_QCameraLens(PyObject *enclosingClass);
void init_Qt3DRender_QAbstractRayCaster(PyObject *enclosingClass);
void init_Qt3DRender_QScreenRayCaster(PyObject *enclosingClass);
void init_Qt3DRender_QRayCaster(PyObject *enclosingClass);
void init_Qt3DRender_QAbstractLight(PyObject *enclosingClass);
void init_Qt3DRender_QSpotLight(PyObject *enclosingClass);
void init_Qt3DRender_QPointLight(PyObject *enclosingClass);
void init_Qt3DRender_QDirectionalLight(PyObject *enclosingClass);
void init_Qt3DRender_QPickingProxy(PyObject *enclosingClass);
void init_Qt3DRender_QGeometryRenderer(PyObject *enclosingClass);
void init_Qt3DRender_QMesh(PyObject *enclosingClass);
void init_Qt3DRender_QTextureImageDataGenerator(PyObject *enclosingClass);
void init_Qt3DRender_QRenderAspect(PyObject *enclosingClass);

// Required modules' type and converter arrays.
PyTypeObject **SbkPySide6_Qt3DCoreTypes;
SbkConverter **SbkPySide6_Qt3DCoreTypeConverters;
PyTypeObject **SbkPySide6_QtGuiTypes;
SbkConverter **SbkPySide6_QtGuiTypeConverters;
PyTypeObject **SbkPySide6_QtCoreTypes;
SbkConverter **SbkPySide6_QtCoreTypeConverters;

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

// C++ to Python conversion for container type 'QList<Qt3DCore::QNode* >'.
static PyObject *_QList_Qt3DCore_QNodePTR__CppToPython__QList_Qt3DCore_QNodePTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Qt3DCore::QNode* > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::pointerToPython(SbkPySide6_Qt3DCoreTypes[SBK_QT3DCORE_QNODE_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Qt3DCore_QNodePTR__PythonToCpp__QList_Qt3DCore_QNodePTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Qt3DCore::QNode* > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::Qt3DCore::QNode* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_Qt3DCoreTypes[SBK_QT3DCORE_QNODE_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Qt3DCore_QNodePTR__PythonToCpp__QList_Qt3DCore_QNodePTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_Qt3DCoreTypes[SBK_QT3DCORE_QNODE_IDX], pyIn))
        return _QList_Qt3DCore_QNodePTR__PythonToCpp__QList_Qt3DCore_QNodePTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<Qt3DRender::QFilterKey* >'.
static PyObject *_QList_Qt3DRender_QFilterKeyPTR__CppToPython__QList_Qt3DRender_QFilterKeyPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Qt3DRender::QFilterKey* > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::pointerToPython(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QFILTERKEY_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Qt3DRender_QFilterKeyPTR__PythonToCpp__QList_Qt3DRender_QFilterKeyPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Qt3DRender::QFilterKey* > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::Qt3DRender::QFilterKey* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QFILTERKEY_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Qt3DRender_QFilterKeyPTR__PythonToCpp__QList_Qt3DRender_QFilterKeyPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QFILTERKEY_IDX], pyIn))
        return _QList_Qt3DRender_QFilterKeyPTR__PythonToCpp__QList_Qt3DRender_QFilterKeyPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<Qt3DRender::QParameter* >'.
static PyObject *_QList_Qt3DRender_QParameterPTR__CppToPython__QList_Qt3DRender_QParameterPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Qt3DRender::QParameter* > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::pointerToPython(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QPARAMETER_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Qt3DRender_QParameterPTR__PythonToCpp__QList_Qt3DRender_QParameterPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Qt3DRender::QParameter* > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::Qt3DRender::QParameter* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QPARAMETER_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Qt3DRender_QParameterPTR__PythonToCpp__QList_Qt3DRender_QParameterPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QPARAMETER_IDX], pyIn))
        return _QList_Qt3DRender_QParameterPTR__PythonToCpp__QList_Qt3DRender_QParameterPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<Qt3DRender::QRenderPass* >'.
static PyObject *_QList_Qt3DRender_QRenderPassPTR__CppToPython__QList_Qt3DRender_QRenderPassPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Qt3DRender::QRenderPass* > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::pointerToPython(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QRENDERPASS_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Qt3DRender_QRenderPassPTR__PythonToCpp__QList_Qt3DRender_QRenderPassPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Qt3DRender::QRenderPass* > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::Qt3DRender::QRenderPass* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QRENDERPASS_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Qt3DRender_QRenderPassPTR__PythonToCpp__QList_Qt3DRender_QRenderPassPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QRENDERPASS_IDX], pyIn))
        return _QList_Qt3DRender_QRenderPassPTR__PythonToCpp__QList_Qt3DRender_QRenderPassPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<QObject* >'.
static PyObject *_QList_QObjectPTR__CppToPython__QList_QObjectPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QObject* > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::pointerToPython(SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QObjectPTR__PythonToCpp__QList_QObjectPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QObject* > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::QObject* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QObjectPTR__PythonToCpp__QList_QObjectPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_QtCoreTypes[SBK_QOBJECT_IDX], pyIn))
        return _QList_QObjectPTR__PythonToCpp__QList_QObjectPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<QByteArray >'.
static PyObject *_QList_QByteArray__CppToPython__QList_QByteArray_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<QByteArray > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::copyToPython(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_QByteArray__PythonToCpp__QList_QByteArray_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QByteArray > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::QByteArray cppItem;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QByteArray__PythonToCpp__QList_QByteArray__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtCoreTypes[SBK_QBYTEARRAY_IDX], pyIn))
        return _QList_QByteArray__PythonToCpp__QList_QByteArray_;
    return {};
}

// C++ to Python conversion for container type 'QList<Qt3DCore::QEntity* >'.
static PyObject *_QList_Qt3DCore_QEntityPTR__CppToPython__QList_Qt3DCore_QEntityPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Qt3DCore::QEntity* > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::pointerToPython(SbkPySide6_Qt3DCoreTypes[SBK_QT3DCORE_QENTITY_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Qt3DCore_QEntityPTR__PythonToCpp__QList_Qt3DCore_QEntityPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Qt3DCore::QEntity* > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::Qt3DCore::QEntity* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_Qt3DCoreTypes[SBK_QT3DCORE_QENTITY_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Qt3DCore_QEntityPTR__PythonToCpp__QList_Qt3DCore_QEntityPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_Qt3DCoreTypes[SBK_QT3DCORE_QENTITY_IDX], pyIn))
        return _QList_Qt3DCore_QEntityPTR__PythonToCpp__QList_Qt3DCore_QEntityPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<Qt3DRender::QRenderState* >'.
static PyObject *_QList_Qt3DRender_QRenderStatePTR__CppToPython__QList_Qt3DRender_QRenderStatePTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Qt3DRender::QRenderState* > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::pointerToPython(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QRENDERSTATE_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Qt3DRender_QRenderStatePTR__PythonToCpp__QList_Qt3DRender_QRenderStatePTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Qt3DRender::QRenderState* > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::Qt3DRender::QRenderState* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QRENDERSTATE_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Qt3DRender_QRenderStatePTR__PythonToCpp__QList_Qt3DRender_QRenderStatePTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QRENDERSTATE_IDX], pyIn))
        return _QList_Qt3DRender_QRenderStatePTR__PythonToCpp__QList_Qt3DRender_QRenderStatePTR_;
    return {};
}

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

}
static void _QList_qreal__PythonToCpp__QList_qreal_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<qreal > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        qreal cppItem;
    Shiboken::Conversions::pythonToCppCopy(Shiboken::Conversions::PrimitiveTypeConverter<qreal>(), pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_qreal__PythonToCpp__QList_qreal__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Conversions::PrimitiveTypeConverter<qreal>(), pyIn))
        return _QList_qreal__PythonToCpp__QList_qreal_;
    return {};
}

// C++ to Python conversion for container type 'QList<Qt3DRender::QTechnique* >'.
static PyObject *_QList_Qt3DRender_QTechniquePTR__CppToPython__QList_Qt3DRender_QTechniquePTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Qt3DRender::QTechnique* > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::pointerToPython(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QTECHNIQUE_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Qt3DRender_QTechniquePTR__PythonToCpp__QList_Qt3DRender_QTechniquePTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Qt3DRender::QTechnique* > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::Qt3DRender::QTechnique* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QTECHNIQUE_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Qt3DRender_QTechniquePTR__PythonToCpp__QList_Qt3DRender_QTechniquePTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QTECHNIQUE_IDX], pyIn))
        return _QList_Qt3DRender_QTechniquePTR__PythonToCpp__QList_Qt3DRender_QTechniquePTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<Qt3DCore::QComponent* >'.
static PyObject *_QList_Qt3DCore_QComponentPTR__CppToPython__QList_Qt3DCore_QComponentPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Qt3DCore::QComponent* > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::pointerToPython(SbkPySide6_Qt3DCoreTypes[SBK_QT3DCORE_QCOMPONENT_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Qt3DCore_QComponentPTR__PythonToCpp__QList_Qt3DCore_QComponentPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Qt3DCore::QComponent* > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::Qt3DCore::QComponent* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_Qt3DCoreTypes[SBK_QT3DCORE_QCOMPONENT_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Qt3DCore_QComponentPTR__PythonToCpp__QList_Qt3DCore_QComponentPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_Qt3DCoreTypes[SBK_QT3DCORE_QCOMPONENT_IDX], pyIn))
        return _QList_Qt3DCore_QComponentPTR__PythonToCpp__QList_Qt3DCore_QComponentPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<Qt3DRender::QRenderTargetOutput* >'.
static PyObject *_QList_Qt3DRender_QRenderTargetOutputPTR__CppToPython__QList_Qt3DRender_QRenderTargetOutputPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Qt3DRender::QRenderTargetOutput* > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::pointerToPython(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QRENDERTARGETOUTPUT_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Qt3DRender_QRenderTargetOutputPTR__PythonToCpp__QList_Qt3DRender_QRenderTargetOutputPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Qt3DRender::QRenderTargetOutput* > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::Qt3DRender::QRenderTargetOutput* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QRENDERTARGETOUTPUT_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Qt3DRender_QRenderTargetOutputPTR__PythonToCpp__QList_Qt3DRender_QRenderTargetOutputPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QRENDERTARGETOUTPUT_IDX], pyIn))
        return _QList_Qt3DRender_QRenderTargetOutputPTR__PythonToCpp__QList_Qt3DRender_QRenderTargetOutputPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<Qt3DRender::QSortPolicy::SortType >'.
static PyObject *_QList_Qt3DRender_QSortPolicy_SortType__CppToPython__QList_Qt3DRender_QSortPolicy_SortType_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Qt3DRender::QSortPolicy::SortType > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::copyToPython(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QSORTPOLICY_SORTTYPE_IDX]))->converter, &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Qt3DRender_QSortPolicy_SortType__PythonToCpp__QList_Qt3DRender_QSortPolicy_SortType_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Qt3DRender::QSortPolicy::SortType > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::Qt3DRender::QSortPolicy::SortType cppItem = static_cast< ::Qt3DRender::QSortPolicy::SortType>(0);
    Shiboken::Conversions::pythonToCppCopy(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QSORTPOLICY_SORTTYPE_IDX]))->converter, pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Qt3DRender_QSortPolicy_SortType__PythonToCpp__QList_Qt3DRender_QSortPolicy_SortType__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(PepType_SETP(reinterpret_cast<SbkEnumType *>(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QSORTPOLICY_SORTTYPE_IDX]))->converter, pyIn))
        return _QList_Qt3DRender_QSortPolicy_SortType__PythonToCpp__QList_Qt3DRender_QSortPolicy_SortType_;
    return {};
}

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

}
static void _QList_int__PythonToCpp__QList_int_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<int > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        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 << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_int__PythonToCpp__QList_int__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(Shiboken::Conversions::PrimitiveTypeConverter<int>(), pyIn))
        return _QList_int__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))))) {
            PyErr_SetString(PyExc_TypeError, "Wrong type passed to container conversion.");
            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"},
    {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:Qt3DRender.QIntList",
    sizeof(ShibokenContainer),
    0,
    Py_TPFLAGS_DEFAULT,
    QIntList_slots
};

static inline PyTypeObject *createQIntListType()
{
    auto *result = reinterpret_cast<PyTypeObject *>(SbkType_FromSpec(&QIntList_spec));
    Py_INCREF(Py_True);
    PyDict_SetItem(result->tp_dict, 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 {};
}

// C++ to Python conversion for container type 'QList<Qt3DRender::QLayer* >'.
static PyObject *_QList_Qt3DRender_QLayerPTR__CppToPython__QList_Qt3DRender_QLayerPTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Qt3DRender::QLayer* > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::pointerToPython(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QLAYER_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Qt3DRender_QLayerPTR__PythonToCpp__QList_Qt3DRender_QLayerPTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Qt3DRender::QLayer* > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::Qt3DRender::QLayer* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QLAYER_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Qt3DRender_QLayerPTR__PythonToCpp__QList_Qt3DRender_QLayerPTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QLAYER_IDX], pyIn))
        return _QList_Qt3DRender_QLayerPTR__PythonToCpp__QList_Qt3DRender_QLayerPTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<Qt3DRender::QAbstractTextureImage* >'.
static PyObject *_QList_Qt3DRender_QAbstractTextureImagePTR__CppToPython__QList_Qt3DRender_QAbstractTextureImagePTR_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Qt3DRender::QAbstractTextureImage* > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::pointerToPython(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QABSTRACTTEXTUREIMAGE_IDX], cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Qt3DRender_QAbstractTextureImagePTR__PythonToCpp__QList_Qt3DRender_QAbstractTextureImagePTR_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Qt3DRender::QAbstractTextureImage* > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::Qt3DRender::QAbstractTextureImage* cppItem{nullptr};
    Shiboken::Conversions::pythonToCppPointer(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QABSTRACTTEXTUREIMAGE_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Qt3DRender_QAbstractTextureImagePTR__PythonToCpp__QList_Qt3DRender_QAbstractTextureImagePTR__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::checkSequenceTypes(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QABSTRACTTEXTUREIMAGE_IDX], pyIn))
        return _QList_Qt3DRender_QAbstractTextureImagePTR__PythonToCpp__QList_Qt3DRender_QAbstractTextureImagePTR_;
    return {};
}

// C++ to Python conversion for container type 'QList<Qt3DRender::QRayCasterHit >'.
static PyObject *_QList_Qt3DRender_QRayCasterHit__CppToPython__QList_Qt3DRender_QRayCasterHit_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QList<Qt3DRender::QRayCasterHit > *>(cppIn);
    // TEMPLATE - cpplist_to_pylist_conversion - START
    PyObject *pyOut = PyList_New(Py_ssize_t(cppInRef.size()));
    Py_ssize_t idx = 0;
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); it != end; ++it, ++idx) {
        const auto &cppItem = *it;
        PyList_SET_ITEM(pyOut, idx, Shiboken::Conversions::copyToPython(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QRAYCASTERHIT_IDX], &cppItem));
    }
    return pyOut;
    // TEMPLATE - cpplist_to_pylist_conversion - END

}
static void _QList_Qt3DRender_QRayCasterHit__PythonToCpp__QList_Qt3DRender_QRayCasterHit_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<Qt3DRender::QRayCasterHit > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        if (pyItem.isNull()) {
            if (PyErr_Occurred() && PyErr_ExceptionMatches(PyExc_StopIteration))
                PyErr_Clear();
            break;
        }
        ::Qt3DRender::QRayCasterHit cppItem;
    Shiboken::Conversions::pythonToCppCopy(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QRAYCASTERHIT_IDX], pyItem, &(cppItem));
        cppOutRef << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_Qt3DRender_QRayCasterHit__PythonToCpp__QList_Qt3DRender_QRayCasterHit__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_Qt3DRenderTypes[SBK_QT3DRENDER_QRAYCASTERHIT_IDX], pyIn))
        return _QList_Qt3DRender_QRayCasterHit__PythonToCpp__QList_Qt3DRender_QRayCasterHit_;
    return {};
}

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

}
static void _QList_QVariant__PythonToCpp__QList_QVariant_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QVariant > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        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 << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QVariant__PythonToCpp__QList_QVariant__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtCoreTypeConverters[SBK_QVARIANT_IDX], pyIn))
        return _QList_QVariant__PythonToCpp__QList_QVariant_;
    return {};
}

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

}
static void _QList_QString__PythonToCpp__QList_QString_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QList<QString > *>(cppOut);
    // TEMPLATE - pyseq_to_cpplist_conversion - START
    // PYSIDE-795: Turn all sequences into iterables.
    if (PyList_Check(pyIn)) {
        const Py_ssize_t size = PySequence_Size(pyIn);
        if (size > 10)
            (cppOutRef).reserve(size);
    }

    Shiboken::AutoDecRef it(PyObject_GetIter(pyIn));
    PyObject *(*iternext)(PyObject *) = *Py_TYPE(it)->tp_iternext;
    for (;;) {
        Shiboken::AutoDecRef pyItem(iternext(it));
        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 << cppItem;
    }
    // TEMPLATE - pyseq_to_cpplist_conversion - END

}
static PythonToCppFunc is__QList_QString__PythonToCpp__QList_QString__Convertible(PyObject *pyIn)
{
    if (Shiboken::Conversions::convertibleSequenceTypes(SbkPySide6_QtCoreTypeConverters[SBK_QSTRING_IDX], pyIn))
        return _QList_QString__PythonToCpp__QList_QString_;
    return {};
}

// C++ to Python conversion for container type 'QMap<QString,QVariant >'.
static PyObject *_QMap_QString_QVariant__CppToPython__QMap_QString_QVariant_(const void *cppIn)
{
    const auto &cppInRef = *reinterpret_cast<const ::QMap<QString,QVariant > *>(cppIn);
    // TEMPLATE - cppmap_to_pymap_conversion - START
    PyObject *pyOut = PyDict_New();
    for (auto it = cppInRef.cbegin(), end = cppInRef.cend(); 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 - cppmap_to_pymap_conversion - END

}
static void _QMap_QString_QVariant__PythonToCpp__QMap_QString_QVariant_(PyObject *pyIn, void *cppOut)
{
    auto &cppOutRef = *reinterpret_cast<::QMap<QString,QVariant > *>(cppOut);
    // TEMPLATE - pydict_to_cppmap_conversion - START
    PyObject *key;
    PyObject *value;
    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 - pydict_to_cppmap_conversion - END

}
static PythonToCppFunc is__QMap_QString_QVariant__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 _QMap_QString_QVariant__PythonToCpp__QMap_QString_QVariant_;
    return {};
}


static struct PyModuleDef moduledef = {
    /* m_base     */ PyModuleDef_HEAD_INIT,
    /* m_name     */ "Qt3DRender",
    /* m_doc      */ nullptr,
    /* m_size     */ -1,
    /* m_methods  */ Qt3DRender_methods,
    /* m_reload   */ nullptr,
    /* m_traverse */ nullptr,
    /* m_clear    */ nullptr,
    /* m_free     */ nullptr
};

// The signatures string for the global functions.
// Multiple signatures have their index "n:" in front.
static const char *Qt3DRender_SignatureStrings[] = {
    nullptr}; // Sentinel

extern "C" LIBSHIBOKEN_EXPORT PyObject *PyInit_Qt3DRender()
{
    if (SbkPySide6_Qt3DRenderModuleObject != nullptr)
        return SbkPySide6_Qt3DRenderModuleObject;
    {
        Shiboken::AutoDecRef requiredModule(Shiboken::Module::import("PySide6.Qt3DCore"));
        if (requiredModule.isNull())
            return nullptr;
        SbkPySide6_Qt3DCoreTypes = Shiboken::Module::getTypes(requiredModule);
        SbkPySide6_Qt3DCoreTypeConverters = Shiboken::Module::getTypeConverters(requiredModule);
    }

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

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

    // Create an array of wrapper types for the current module.
    static PyTypeObject *cppApi[SBK_Qt3DRender_IDX_COUNT];
    SbkPySide6_Qt3DRenderTypes = cppApi;

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

    PyObject *module = Shiboken::Module::create("Qt3DRender", &moduledef);

    // Make module available from global scope
    SbkPySide6_Qt3DRenderModuleObject = module;

    // Initialize classes in the type system
    init_Qt3DRenderQt3DRender(module);
    init_Qt3DRender_QTextureWrapMode(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTextureImageData(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTextureDataUpdate(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTextureData(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QStencilTestArguments(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QStencilOperationArguments(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRenderCaptureReply(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRenderCapabilities(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRayCasterHit(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QPickEvent(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QPickTriangleEvent(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QPickPointEvent(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QPickLineEvent(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QLevelOfDetailBoundingSphere(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QGraphicsApiFilter(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_PropertyReaderInterface(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTechnique(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QShaderProgramBuilder(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QShaderProgram(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QShaderImage(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRenderTargetOutput(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRenderState(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QStencilTest(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QStencilOperation(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QStencilMask(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QSeamlessCubemap(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QScissorTest(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRasterMode(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QPolygonOffset(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QPointSize(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QNoDepthMask(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QMultiSampleAntiAliasing(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QLineWidth(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QFrontFace(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QDithering(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QDepthTest(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QDepthRange(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QCullFace(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QColorMask(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QClipPlane(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QBlendEquationArguments(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QBlendEquation(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QAlphaTest(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QAlphaCoverage(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRenderPass(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QPickingSettings(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QParameter(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QFrameGraphNode(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QWaitFence(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QViewport(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTechniqueFilter(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QSubtreeEnabler(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QSortPolicy(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QSetFence(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRenderTargetSelector(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRenderSurfaceSelector(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRenderStateSet(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRenderPassFilter(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRenderCapture(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QProximityFilter(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QNoPicking(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QNoDraw(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QMemoryBarrier(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QLayerFilter(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QFrustumCulling(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QDispatchCompute(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QClearBuffers(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QCameraSelector(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QBufferCapture(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QBlitFramebuffer(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QFilterKey(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QEffect(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QAbstractTextureImage(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTextureImage(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QPaintedTextureImage(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QAbstractTexture(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTextureRectangle(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTextureLoader(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTextureCubeMapArray(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTextureCubeMap(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTextureBuffer(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTexture3D(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTexture2DMultisampleArray(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTexture2DMultisample(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTexture2DArray(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTexture2D(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTexture1DArray(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTexture1D(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QSharedGLTexture(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QCamera(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QShaderData(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QSceneLoader(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRenderTarget(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRenderSettings(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QObjectPicker(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QMaterial(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QLevelOfDetail(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QLevelOfDetailSwitch(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QLayer(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QEnvironmentLight(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QComputeCommand(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QCameraLens(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QAbstractRayCaster(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QScreenRayCaster(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRayCaster(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QAbstractLight(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QSpotLight(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QPointLight(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QDirectionalLight(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QPickingProxy(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QGeometryRenderer(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QMesh(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QTextureImageDataGenerator(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);
    init_Qt3DRender_QRenderAspect(reinterpret_cast<PyTypeObject *>(SbkPySide6_Qt3DRenderTypes[SBK_Qt3DRenderQT3DRENDER_IDX])->tp_dict);

    // Register converter for type 'QList<Qt3DCore::QNode*>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DCORE_QNODEPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Qt3DCore_QNodePTR__CppToPython__QList_Qt3DCore_QNodePTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DCORE_QNODEPTR_IDX], "QList<Qt3DCore::QNode*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DCORE_QNODEPTR_IDX],
        _QList_Qt3DCore_QNodePTR__PythonToCpp__QList_Qt3DCore_QNodePTR_,
        is__QList_Qt3DCore_QNodePTR__PythonToCpp__QList_Qt3DCore_QNodePTR__Convertible);

    // Register converter for type 'QList<Qt3DRender::QFilterKey*>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QFILTERKEYPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Qt3DRender_QFilterKeyPTR__CppToPython__QList_Qt3DRender_QFilterKeyPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QFILTERKEYPTR_IDX], "QList<Qt3DRender::QFilterKey*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QFILTERKEYPTR_IDX],
        _QList_Qt3DRender_QFilterKeyPTR__PythonToCpp__QList_Qt3DRender_QFilterKeyPTR_,
        is__QList_Qt3DRender_QFilterKeyPTR__PythonToCpp__QList_Qt3DRender_QFilterKeyPTR__Convertible);

    // Register converter for type 'QList<Qt3DRender::QParameter*>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QPARAMETERPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Qt3DRender_QParameterPTR__CppToPython__QList_Qt3DRender_QParameterPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QPARAMETERPTR_IDX], "QList<Qt3DRender::QParameter*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QPARAMETERPTR_IDX],
        _QList_Qt3DRender_QParameterPTR__PythonToCpp__QList_Qt3DRender_QParameterPTR_,
        is__QList_Qt3DRender_QParameterPTR__PythonToCpp__QList_Qt3DRender_QParameterPTR__Convertible);

    // Register converter for type 'QList<Qt3DRender::QRenderPass*>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QRENDERPASSPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Qt3DRender_QRenderPassPTR__CppToPython__QList_Qt3DRender_QRenderPassPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QRENDERPASSPTR_IDX], "QList<Qt3DRender::QRenderPass*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QRENDERPASSPTR_IDX],
        _QList_Qt3DRender_QRenderPassPTR__PythonToCpp__QList_Qt3DRender_QRenderPassPTR_,
        is__QList_Qt3DRender_QRenderPassPTR__PythonToCpp__QList_Qt3DRender_QRenderPassPTR__Convertible);

    // Register converter for type 'QList<QObject*>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QOBJECTPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QObjectPTR__CppToPython__QList_QObjectPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QOBJECTPTR_IDX], "QList<QObject*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QOBJECTPTR_IDX],
        _QList_QObjectPTR__PythonToCpp__QList_QObjectPTR_,
        is__QList_QObjectPTR__PythonToCpp__QList_QObjectPTR__Convertible);

    // Register converter for type 'QList<QByteArray>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QBYTEARRAY_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QByteArray__CppToPython__QList_QByteArray_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QBYTEARRAY_IDX], "QList<QByteArray>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QBYTEARRAY_IDX],
        _QList_QByteArray__PythonToCpp__QList_QByteArray_,
        is__QList_QByteArray__PythonToCpp__QList_QByteArray__Convertible);

    // Register converter for type 'QList<Qt3DCore::QEntity*>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DCORE_QENTITYPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Qt3DCore_QEntityPTR__CppToPython__QList_Qt3DCore_QEntityPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DCORE_QENTITYPTR_IDX], "QList<Qt3DCore::QEntity*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DCORE_QENTITYPTR_IDX],
        _QList_Qt3DCore_QEntityPTR__PythonToCpp__QList_Qt3DCore_QEntityPTR_,
        is__QList_Qt3DCore_QEntityPTR__PythonToCpp__QList_Qt3DCore_QEntityPTR__Convertible);

    // Register converter for type 'QList<Qt3DRender::QRenderState*>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QRENDERSTATEPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Qt3DRender_QRenderStatePTR__CppToPython__QList_Qt3DRender_QRenderStatePTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QRENDERSTATEPTR_IDX], "QList<Qt3DRender::QRenderState*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QRENDERSTATEPTR_IDX],
        _QList_Qt3DRender_QRenderStatePTR__PythonToCpp__QList_Qt3DRender_QRenderStatePTR_,
        is__QList_Qt3DRender_QRenderStatePTR__PythonToCpp__QList_Qt3DRender_QRenderStatePTR__Convertible);

    // Register converter for type 'QList<qreal>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QREAL_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_qreal__CppToPython__QList_qreal_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QREAL_IDX], "QList<qreal>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QREAL_IDX],
        _QList_qreal__PythonToCpp__QList_qreal_,
        is__QList_qreal__PythonToCpp__QList_qreal__Convertible);

    // Register converter for type 'QList<Qt3DRender::QTechnique*>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QTECHNIQUEPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Qt3DRender_QTechniquePTR__CppToPython__QList_Qt3DRender_QTechniquePTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QTECHNIQUEPTR_IDX], "QList<Qt3DRender::QTechnique*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QTECHNIQUEPTR_IDX],
        _QList_Qt3DRender_QTechniquePTR__PythonToCpp__QList_Qt3DRender_QTechniquePTR_,
        is__QList_Qt3DRender_QTechniquePTR__PythonToCpp__QList_Qt3DRender_QTechniquePTR__Convertible);

    // Register converter for type 'QList<Qt3DCore::QComponent*>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DCORE_QCOMPONENTPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Qt3DCore_QComponentPTR__CppToPython__QList_Qt3DCore_QComponentPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DCORE_QCOMPONENTPTR_IDX], "QList<Qt3DCore::QComponent*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DCORE_QCOMPONENTPTR_IDX],
        _QList_Qt3DCore_QComponentPTR__PythonToCpp__QList_Qt3DCore_QComponentPTR_,
        is__QList_Qt3DCore_QComponentPTR__PythonToCpp__QList_Qt3DCore_QComponentPTR__Convertible);

    // Register converter for type 'QList<Qt3DRender::QRenderTargetOutput*>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QRENDERTARGETOUTPUTPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Qt3DRender_QRenderTargetOutputPTR__CppToPython__QList_Qt3DRender_QRenderTargetOutputPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QRENDERTARGETOUTPUTPTR_IDX], "QList<Qt3DRender::QRenderTargetOutput*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QRENDERTARGETOUTPUTPTR_IDX],
        _QList_Qt3DRender_QRenderTargetOutputPTR__PythonToCpp__QList_Qt3DRender_QRenderTargetOutputPTR_,
        is__QList_Qt3DRender_QRenderTargetOutputPTR__PythonToCpp__QList_Qt3DRender_QRenderTargetOutputPTR__Convertible);

    // Register converter for type 'QList<Qt3DRender::QSortPolicy::SortType>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QSORTPOLICY_SORTTYPE_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Qt3DRender_QSortPolicy_SortType__CppToPython__QList_Qt3DRender_QSortPolicy_SortType_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QSORTPOLICY_SORTTYPE_IDX], "QList<Qt3DRender::QSortPolicy::SortType>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QSORTPOLICY_SORTTYPE_IDX],
        _QList_Qt3DRender_QSortPolicy_SortType__PythonToCpp__QList_Qt3DRender_QSortPolicy_SortType_,
        is__QList_Qt3DRender_QSortPolicy_SortType__PythonToCpp__QList_Qt3DRender_QSortPolicy_SortType__Convertible);

    // Register converter for type 'QList<int>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_INT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_int__CppToPython__QList_int_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_INT_IDX], "QList<int>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_INT_IDX],
        _QList_int__PythonToCpp__QList_int_,
        is__QList_int__PythonToCpp__QList_int__Convertible);
    Shiboken::Conversions::setPythonToCppPointerFunctions(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_INT_IDX],
        PythonToCppQIntList,
        isQIntListPythonToCppConvertible);

    // Register converter for type 'QList<Qt3DRender::QLayer*>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QLAYERPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Qt3DRender_QLayerPTR__CppToPython__QList_Qt3DRender_QLayerPTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QLAYERPTR_IDX], "QList<Qt3DRender::QLayer*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QLAYERPTR_IDX],
        _QList_Qt3DRender_QLayerPTR__PythonToCpp__QList_Qt3DRender_QLayerPTR_,
        is__QList_Qt3DRender_QLayerPTR__PythonToCpp__QList_Qt3DRender_QLayerPTR__Convertible);

    // Register converter for type 'QList<Qt3DRender::QAbstractTextureImage*>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QABSTRACTTEXTUREIMAGEPTR_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Qt3DRender_QAbstractTextureImagePTR__CppToPython__QList_Qt3DRender_QAbstractTextureImagePTR_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QABSTRACTTEXTUREIMAGEPTR_IDX], "QList<Qt3DRender::QAbstractTextureImage*>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QABSTRACTTEXTUREIMAGEPTR_IDX],
        _QList_Qt3DRender_QAbstractTextureImagePTR__PythonToCpp__QList_Qt3DRender_QAbstractTextureImagePTR_,
        is__QList_Qt3DRender_QAbstractTextureImagePTR__PythonToCpp__QList_Qt3DRender_QAbstractTextureImagePTR__Convertible);

    // Register converter for type 'QList<Qt3DRender::QRayCasterHit>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QRAYCASTERHIT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_Qt3DRender_QRayCasterHit__CppToPython__QList_Qt3DRender_QRayCasterHit_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QRAYCASTERHIT_IDX], "QList<Qt3DRender::QRayCasterHit>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QT3DRENDER_QRAYCASTERHIT_IDX],
        _QList_Qt3DRender_QRayCasterHit__PythonToCpp__QList_Qt3DRender_QRayCasterHit_,
        is__QList_Qt3DRender_QRayCasterHit__PythonToCpp__QList_Qt3DRender_QRayCasterHit__Convertible);

    // Register converter for type 'QList<QVariant>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QVARIANT_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QVariant__CppToPython__QList_QVariant_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QVARIANT_IDX], "QList<QVariant>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QVARIANT_IDX],
        _QList_QVariant__PythonToCpp__QList_QVariant_,
        is__QList_QVariant__PythonToCpp__QList_QVariant__Convertible);

    // Register converter for type 'QList<QString>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QSTRING_IDX] = Shiboken::Conversions::createConverter(&PyList_Type, _QList_QString__CppToPython__QList_QString_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QSTRING_IDX], "QList<QString>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QLIST_QSTRING_IDX],
        _QList_QString__PythonToCpp__QList_QString_,
        is__QList_QString__PythonToCpp__QList_QString__Convertible);

    // Register converter for type 'QMap<QString,QVariant>'.
    SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QMAP_QSTRING_QVARIANT_IDX] = Shiboken::Conversions::createConverter(&PyDict_Type, _QMap_QString_QVariant__CppToPython__QMap_QString_QVariant_);
    Shiboken::Conversions::registerConverterName(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QMAP_QSTRING_QVARIANT_IDX], "QMap<QString,QVariant>");
    Shiboken::Conversions::addPythonToCppValueConversion(SbkPySide6_Qt3DRenderTypeConverters[SBK_QT3DRENDER_QMAP_QSTRING_QVARIANT_IDX],
        _QMap_QString_QVariant__PythonToCpp__QMap_QString_QVariant_,
        is__QMap_QString_QVariant__PythonToCpp__QMap_QString_QVariant__Convertible);


    // Opaque container type registration
    PyObject *ob_type{};
    ob_type = reinterpret_cast<PyObject *>(QIntList_TypeF());
    Py_XINCREF(ob_type);
    PyModule_AddObject(module, "QIntList", ob_type);

    // Register primitive types converters.

    Shiboken::Module::registerTypes(module, SbkPySide6_Qt3DRenderTypes);
    Shiboken::Module::registerTypeConverters(module, SbkPySide6_Qt3DRenderTypeConverters);

    if (PyErr_Occurred()) {
        PyErr_Print();
        Py_FatalError("can't initialize module Qt3DRender");
    }
    PySide::registerCleanupFunction(cleanTypesAttributes);

    FinishSignatureInitialization(module, Qt3DRender_SignatureStrings);

    return module;
}
